Run ExpressionParserTestMixin tests with Fasta.

pkg/analyzer/test/generated/parser_test.dart

Index: pkg/analyzer/test/generated/parser_test.dart
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index ea1386c7b7e51544b0f2c1b3e639a4cf697c3ff0..46512f765aa2296f3235aaa1f6de236108d50319 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -15,7 +15,6 @@ 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/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:test/test.dart';
@@ -79,6 +78,24 @@ abstract class AbstractParserTestCase implements ParserTestHelpers {
    */
   void createParser(String content);
 
+  Expression parseAdditiveExpression(String code);
+
+  Expression parseAssignableExpression(String code, bool primaryAllowed);
+
+  Expression parseAssignableSelector(
+      String code, Expression prefix, bool optional,
+      {bool allowConditional: true});
+
+  AwaitExpression parseAwaitExpression(String code);
+
+  Expression parseBitwiseAndExpression(String code);
+
+  Expression parseBitwiseOrExpression(String code);
+
+  Expression parseBitwiseXorExpression(String code);
+
+  Expression parseCascadeSection(String code);
+
   CompilationUnit parseCompilationUnit(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
@@ -86,6 +103,10 @@ abstract class AbstractParserTestCase implements ParserTestHelpers {
   CompilationUnit parseCompilationUnitWithOptions(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
+  ConditionalExpression parseConditionalExpression(String code);
+
+  Expression parseConstExpression(String code);
+
   /**
    * Parse the given source as a compilation unit.
    *
@@ -98,9 +119,15 @@ abstract class AbstractParserTestCase implements ParserTestHelpers {
   CompilationUnit parseDirectives(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
+  BinaryExpression parseEqualityExpression(String code);
+
   Expression parseExpression(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
+  List<Expression> parseExpressionList(String code);
+
+  Expression parseExpressionWithoutCascade(String code);
+
   FormalParameter parseFormalParameter(String code, ParameterKind kind,
       {List<ErrorCode> errorCodes: const <ErrorCode>[]});
 
@@ -120,12 +147,61 @@ abstract class AbstractParserTestCase implements ParserTestHelpers {
    */
   Directive parseFullDirective();
 
+  FunctionExpression parseFunctionExpression(String code);
+
+  InstanceCreationExpression parseInstanceCreationExpression(
+      String code, Token newToken);
+
+  ListLiteral parseListLiteral(
+      Token token, String typeArgumentsCode, String code);
+
+  TypedLiteral parseListOrMapLiteral(Token modifier, String code);
+
+  Expression parseLogicalAndExpression(String code);
+
+  Expression parseLogicalOrExpression(String code);
+
+  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});
 
+  Expression parsePostfixExpression(String code);
+
+  Identifier parsePrefixedIdentifier(String code);
+
+  Expression parsePrimaryExpression(String code);
+
+  Expression parseRelationalExpression(String code);
+
+  RethrowExpression parseRethrowExpression(String code);
+
+  BinaryExpression parseShiftExpression(String code);
+
+  SimpleIdentifier parseSimpleIdentifier(String code);
+
   Statement parseStatement(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[],
       bool enableLazyAssignmentOperators]);
+
+  Expression parseStringLiteral(String code);
+
+  SuperConstructorInvocation parseSuperConstructorInvocation(String code);
+
+  SymbolLiteral parseSymbolLiteral(String code);
+
+  Expression parseThrowExpression(String code);
+
+  Expression parseThrowExpressionWithoutCascade(String code);
+
+  PrefixExpression parseUnaryExpression(String code);
 }
 
 /**
@@ -2194,8 +2270,7 @@ class Foo {
     // literals that are being created are not always zero length (because they
     // could have type parameters), which violates the contract of
     // isSynthetic().
-    createParser('1');
-    TypedLiteral literal = parser.parseListOrMapLiteral(null);
+    TypedLiteral literal = parseListOrMapLiteral(null, '1');
     expectNotNullIfNoErrors(literal);
     listener
         .assertErrorsWithCodes([ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL]);
@@ -2693,16 +2768,14 @@ class Foo {
   }
 
   void test_invalidOperatorAfterSuper_assignableExpression() {
-    createParser('super?.v');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('super?.v', false);
     expectNotNullIfNoErrors(expression);
     listener
         .assertErrorsWithCodes([ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
   }
 
   void test_invalidOperatorAfterSuper_primaryExpression() {
-    createParser('super?.v');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('super?.v');
     expectNotNullIfNoErrors(expression);
     listener
         .assertErrorsWithCodes([ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
@@ -2731,43 +2804,37 @@ class Foo {
   }
 
   void test_invalidUnicodeEscape_incomplete_noDigits() {
-    createParser("'\\u{'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'\\u{'");
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
 
   void test_invalidUnicodeEscape_incomplete_someDigits() {
-    createParser("'\\u{0A'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'\\u{0A'");
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
 
   void test_invalidUnicodeEscape_invalidDigit() {
-    createParser("'\\u0 a'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'\\u0 a'");
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
 
   void test_invalidUnicodeEscape_tooFewDigits_fixed() {
-    createParser("'\\u04'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'\\u04'");
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
 
   void test_invalidUnicodeEscape_tooFewDigits_variable() {
-    createParser("'\\u{}'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'\\u{}'");
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
 
   void test_invalidUnicodeEscape_tooManyDigits_variable() {
-    createParser("'\\u{12345678}'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'\\u{12345678}'");
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([
       ParserErrorCode.INVALID_UNICODE_ESCAPE,
@@ -3072,15 +3139,13 @@ class Foo {
   }
 
   void test_missingIdentifier_inSymbol_afterPeriod() {
-    createParser('#a.');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#a.');
     expectNotNullIfNoErrors(literal);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_missingIdentifier_inSymbol_first() {
-    createParser('#');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#');
     expectNotNullIfNoErrors(literal);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
   }
@@ -3316,8 +3381,7 @@ class Foo {
 
   @failingTest
   void test_namedFunctionExpression() {
-    createParser('f() {}');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('f() {}');
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.NAMED_FUNCTION_EXPRESSION]);
     expect(expression, new isInstanceOf<FunctionExpression>());
@@ -3956,8 +4020,7 @@ class ExpressionParserTest extends ParserTestCase
 
 abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void test_parseAdditiveExpression_normal() {
-    createParser('x + y');
-    Expression expression = parser.parseAdditiveExpression();
+    Expression expression = parseAdditiveExpression('x + y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -3969,8 +4032,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAdditiveExpression_super() {
-    createParser('super + y');
-    Expression expression = parser.parseAdditiveExpression();
+    Expression expression = parseAdditiveExpression('super + y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -3982,8 +4044,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_expression_args_dot() {
-    createParser('(x)(y).z');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('(x)(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4002,8 +4063,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void
       test_parseAssignableExpression_expression_args_dot_typeParameterComments() {
     enableGenericMethodComments = true;
-    createParser('(x)/*<F>*/(y).z');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('(x)/*<F>*/(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4020,8 +4080,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_expression_args_dot_typeParameters() {
-    createParser('(x)<F>(y).z');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('(x)<F>(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4038,8 +4097,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_expression_dot() {
-    createParser('(x).y');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('(x).y', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4050,8 +4108,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_expression_index() {
-    createParser('(x)[y]');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('(x)[y]', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IndexExpression>());
@@ -4063,8 +4120,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_expression_question_dot() {
-    createParser('(x)?.y');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('(x)?.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4075,8 +4131,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_identifier() {
-    createParser('x');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('x', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleIdentifier>());
@@ -4085,8 +4140,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_identifier_args_dot() {
-    createParser('x(y).z');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('x(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4104,8 +4158,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void
       test_parseAssignableExpression_identifier_args_dot_typeParameterComments() {
     enableGenericMethodComments = true;
-    createParser('x/*<E>*/(y).z');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('x/*<E>*/(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4121,8 +4174,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_identifier_args_dot_typeParameters() {
-    createParser('x<E>(y).z');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('x<E>(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4138,8 +4190,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_identifier_dot() {
-    createParser('x.y');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('x.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4151,8 +4202,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_identifier_index() {
-    createParser('x[y]');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('x[y]', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IndexExpression>());
@@ -4164,8 +4214,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_identifier_question_dot() {
-    createParser('x?.y');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('x?.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4176,8 +4225,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_super_dot() {
-    createParser('super.y');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('super.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4189,8 +4237,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableExpression_super_index() {
-    createParser('super[y]');
-    Expression expression = parser.parseAssignableExpression(false);
+    Expression expression = parseAssignableExpression('super[y]', false);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IndexExpression>());
@@ -4202,8 +4249,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableSelector_dot() {
-    createParser('.x');
-    Expression expression = parser.parseAssignableSelector(null, true);
+    Expression expression = parseAssignableSelector('.x', null, true);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4213,8 +4259,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableSelector_index() {
-    createParser('[x]');
-    Expression expression = parser.parseAssignableSelector(null, true);
+    Expression expression = parseAssignableSelector('[x]', null, true);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IndexExpression>());
@@ -4225,9 +4270,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableSelector_none() {
-    createParser(';');
     Expression expression =
-        parser.parseAssignableSelector(astFactory.simpleIdentifier(null), true);
+        parseAssignableSelector(';', astFactory.simpleIdentifier(null), true);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleIdentifier>());
@@ -4236,8 +4280,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAssignableSelector_question_dot() {
-    createParser('?.x');
-    Expression expression = parser.parseAssignableSelector(null, true);
+    Expression expression = parseAssignableSelector('?.x', null, true);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4247,8 +4290,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseAwaitExpression() {
-    createParser('await x;');
-    AwaitExpression expression = parser.parseAwaitExpression();
+    AwaitExpression expression = parseAwaitExpression('await x;');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.awaitKeyword, isNotNull);
@@ -4256,8 +4298,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseBitwiseAndExpression_normal() {
-    createParser('x & y');
-    Expression expression = parser.parseBitwiseAndExpression();
+    Expression expression = parseBitwiseAndExpression('x & y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -4269,8 +4310,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseBitwiseAndExpression_super() {
-    createParser('super & y');
-    Expression expression = parser.parseBitwiseAndExpression();
+    Expression expression = parseBitwiseAndExpression('super & y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -4282,8 +4322,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseBitwiseOrExpression_normal() {
-    createParser('x | y');
-    Expression expression = parser.parseBitwiseOrExpression();
+    Expression expression = parseBitwiseOrExpression('x | y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -4295,8 +4334,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseBitwiseOrExpression_super() {
-    createParser('super | y');
-    Expression expression = parser.parseBitwiseOrExpression();
+    Expression expression = parseBitwiseOrExpression('super | y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -4308,8 +4346,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseBitwiseXorExpression_normal() {
-    createParser('x ^ y');
-    Expression expression = parser.parseBitwiseXorExpression();
+    Expression expression = parseBitwiseXorExpression('x ^ y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -4321,8 +4358,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseBitwiseXorExpression_super() {
-    createParser('super ^ y');
-    Expression expression = parser.parseBitwiseXorExpression();
+    Expression expression = parseBitwiseXorExpression('super ^ y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -4334,8 +4370,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_i() {
-    createParser('..[i]');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..[i]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IndexExpression>());
@@ -4347,8 +4382,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_ia() {
-    createParser('..[i](b)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..[i](b)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4360,8 +4394,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseCascadeSection_ia_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('..[i]/*<E>*/(b)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..[i]/*<E>*/(b)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4372,8 +4405,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_ia_typeArguments() {
-    createParser('..[i]<E>(b)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..[i]<E>(b)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4384,8 +4416,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_ii() {
-    createParser('..a(b).c(d)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a(b).c(d)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -4400,8 +4431,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseCascadeSection_ii_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('..a/*<E>*/(b).c/*<F>*/(d)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a/*<E>*/(b).c/*<F>*/(d)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -4415,8 +4445,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_ii_typeArguments() {
-    createParser('..a<E>(b).c<F>(d)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a<E>(b).c<F>(d)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -4430,8 +4459,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_p() {
-    createParser('..a');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4442,8 +4470,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_p_assign() {
-    createParser('..a = 3');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a = 3');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AssignmentExpression>());
@@ -4455,8 +4482,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_p_assign_withCascade() {
-    createParser('..a = 3..m()');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a = 3..m()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AssignmentExpression>());
@@ -4470,8 +4496,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseCascadeSection_p_assign_withCascade_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('..a = 3..m/*<E>*/()');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a = 3..m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AssignmentExpression>());
@@ -4484,8 +4509,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_p_assign_withCascade_typeArguments() {
-    createParser('..a = 3..m<E>()');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a = 3..m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AssignmentExpression>());
@@ -4498,8 +4522,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_p_builtIn() {
-    createParser('..as');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..as');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4510,8 +4533,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_pa() {
-    createParser('..a(b)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a(b)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -4526,8 +4548,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseCascadeSection_pa_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('..a/*<E>*/(b)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a/*<E>*/(b)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -4541,8 +4562,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_pa_typeArguments() {
-    createParser('..a<E>(b)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a<E>(b)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -4556,8 +4576,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_paa() {
-    createParser('..a(b)(c)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a(b)(c)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4570,8 +4589,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseCascadeSection_paa_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('..a/*<E>*/(b)/*<F>*/(c)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a/*<E>*/(b)/*<F>*/(c)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4583,8 +4601,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_paa_typeArguments() {
-    createParser('..a<E>(b)<F>(c)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a<E>(b)<F>(c)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4596,8 +4613,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_paapaa() {
-    createParser('..a(b)(c).d(e)(f)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a(b)(c).d(e)(f)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4610,8 +4626,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseCascadeSection_paapaa_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('..a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e)/*<H>*/(f)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression =
+        parseCascadeSection('..a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e)/*<H>*/(f)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4623,8 +4639,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_paapaa_typeArguments() {
-    createParser('..a<E>(b)<F>(c).d<G>(e)<H>(f)');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression =
+        parseCascadeSection('..a<E>(b)<F>(c).d<G>(e)<H>(f)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
@@ -4636,8 +4652,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_pap() {
-    createParser('..a(b).c');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a(b).c');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4649,8 +4664,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseCascadeSection_pap_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('..a/*<E>*/(b).c');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a/*<E>*/(b).c');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4661,8 +4675,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseCascadeSection_pap_typeArguments() {
-    createParser('..a<E>(b).c');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a<E>(b).c');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -4673,8 +4686,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseConditionalExpression() {
-    createParser('x ? y : z');
-    ConditionalExpression expression = parser.parseConditionalExpression();
+    ConditionalExpression expression = parseConditionalExpression('x ? y : z');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.condition, isNotNull);
@@ -4685,8 +4697,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseConstExpression_instanceCreation() {
-    createParser('const A()');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<InstanceCreationExpression>());
@@ -4701,8 +4712,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseConstExpression_listLiteral_typed() {
-    createParser('const <A> []');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const <A> []');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
@@ -4716,8 +4726,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseConstExpression_listLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
-    createParser('const /*<A>*/ []');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const /*<A>*/ []');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
@@ -4730,8 +4739,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseConstExpression_listLiteral_untyped() {
-    createParser('const []');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const []');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
@@ -4744,8 +4752,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseConstExpression_mapLiteral_typed() {
-    createParser('const <A, B> {}');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const <A, B> {}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
@@ -4758,8 +4765,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseConstExpression_mapLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
-    createParser('const /*<A, B>*/ {}');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const /*<A, B>*/ {}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
@@ -4771,8 +4777,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseConstExpression_mapLiteral_untyped() {
-    createParser('const {}');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const {}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
@@ -4784,8 +4789,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseEqualityExpression_normal() {
-    createParser('x == y');
-    BinaryExpression expression = parser.parseEqualityExpression();
+    BinaryExpression expression = parseEqualityExpression('x == y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, isNotNull);
@@ -4795,8 +4799,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseEqualityExpression_super() {
-    createParser('super == y');
-    BinaryExpression expression = parser.parseEqualityExpression();
+    BinaryExpression expression = parseEqualityExpression('super == y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, new isInstanceOf<SuperExpression>());
@@ -4933,16 +4936,14 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseExpressionList_multiple() {
-    createParser('1, 2, 3');
-    List<Expression> result = parser.parseExpressionList();
+    List<Expression> result = parseExpressionList('1, 2, 3');
     expect(result, isNotNull);
     assertNoErrors();
     expect(result, hasLength(3));
   }
 
   void test_parseExpressionList_single() {
-    createParser('1');
-    List<Expression> result = parser.parseExpressionList();
+    List<Expression> result = parseExpressionList('1');
     expect(result, isNotNull);
     assertNoErrors();
     expect(result, hasLength(1));
@@ -4950,8 +4951,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseExpressionWithoutCascade_assign() {
     // TODO(brianwilkerson) Implement more tests for this method.
-    createParser('x = y');
-    Expression expression = parser.parseExpressionWithoutCascade();
+    Expression expression = parseExpressionWithoutCascade('x = y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AssignmentExpression>());
@@ -4963,8 +4963,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseExpressionWithoutCascade_comparison() {
-    createParser('--a.b == c');
-    Expression expression = parser.parseExpressionWithoutCascade();
+    Expression expression = parseExpressionWithoutCascade('--a.b == c');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -4976,8 +4975,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseExpressionWithoutCascade_superMethodInvocation() {
-    createParser('super.m()');
-    Expression expression = parser.parseExpressionWithoutCascade();
+    Expression expression = parseExpressionWithoutCascade('super.m()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -4991,8 +4989,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void
       test_parseExpressionWithoutCascade_superMethodInvocation_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('super.m/*<E>*/()');
-    Expression expression = parser.parseExpressionWithoutCascade();
+    Expression expression = parseExpressionWithoutCascade('super.m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5005,8 +5002,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void
       test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
-    createParser('super.m<E>()');
-    Expression expression = parser.parseExpressionWithoutCascade();
+    Expression expression = parseExpressionWithoutCascade('super.m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5018,8 +5014,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseFunctionExpression_body_inExpression() {
-    createParser('(int i) => i++');
-    FunctionExpression expression = parser.parseFunctionExpression();
+    FunctionExpression expression = parseFunctionExpression('(int i) => i++');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.body, isNotNull);
@@ -5030,8 +5025,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseFunctionExpression_typeParameterComments() {
     enableGenericMethodComments = true;
-    createParser('/*<E>*/(/*=E*/ i) => i++');
-    FunctionExpression expression = parser.parseFunctionExpression();
+    FunctionExpression expression =
+        parseFunctionExpression('/*<E>*/(/*=E*/ i) => i++');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.body, isNotNull);
@@ -5043,8 +5038,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseFunctionExpression_typeParameters() {
-    createParser('<E>(E i) => i++');
-    FunctionExpression expression = parser.parseFunctionExpression();
+    FunctionExpression expression = parseFunctionExpression('<E>(E i) => i++');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.body, isNotNull);
@@ -5055,9 +5049,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseInstanceCreationExpression_qualifiedType() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A.B()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A.B()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5073,9 +5066,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseInstanceCreationExpression_qualifiedType_named() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A.B.c()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A.B.c()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5093,9 +5085,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
       test_parseInstanceCreationExpression_qualifiedType_named_typeParameterComment() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A.B/*<E>*/.c()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A.B/*<E>*/.c()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5112,9 +5103,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void
       test_parseInstanceCreationExpression_qualifiedType_named_typeParameters() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A.B<E>.c()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A.B<E>.c()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5132,9 +5122,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
       test_parseInstanceCreationExpression_qualifiedType_typeParameterComment() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A.B/*<E>*/()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A.B/*<E>*/()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5150,9 +5139,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseInstanceCreationExpression_qualifiedType_typeParameters() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A.B<E>()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A.B<E>()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5168,9 +5156,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseInstanceCreationExpression_type() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5187,9 +5174,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void test_parseInstanceCreationExpression_type_named() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A.c()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A.c()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5206,9 +5192,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void test_parseInstanceCreationExpression_type_named_typeParameterComment() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A/*<B>*/.c()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A/*<B>*/.c()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5224,9 +5209,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseInstanceCreationExpression_type_named_typeParameters() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A<B>.c()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A<B>.c()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5243,9 +5227,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void test_parseInstanceCreationExpression_type_typeParameterComment() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A/*<B>*/()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A/*<B>*/()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5261,9 +5244,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseInstanceCreationExpression_type_typeParameters() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A<B>()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A<B>()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5280,9 +5262,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void test_parseInstanceCreationExpression_type_typeParameters_nullable() {
     enableNnbd = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    createParser('A<B?>()');
     InstanceCreationExpression expression =
-        parser.parseInstanceCreationExpression(token);
+        parseInstanceCreationExpression('A<B?>()', token);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, token);
@@ -5300,27 +5281,22 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseListLiteral_empty_oneToken() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
-    TypeArgumentList typeArguments = null;
-    createParser('[]');
-    ListLiteral literal = parser.parseListLiteral(token, typeArguments);
+    ListLiteral literal = parseListLiteral(token, null, '[]');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.constKeyword, token);
-    expect(literal.typeArguments, typeArguments);
+    expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListLiteral_empty_oneToken_withComment() {
-    Token token = null;
-    TypeArgumentList typeArguments = null;
-    createParser('/* 0 */ []');
-    ListLiteral literal = parser.parseListLiteral(token, typeArguments);
+    ListLiteral literal = parseListLiteral(null, null, '/* 0 */ []');
     expect(literal, isNotNull);
     assertNoErrors();
-    expect(literal.constKeyword, token);
-    expect(literal.typeArguments, typeArguments);
+    expect(literal.constKeyword, isNull);
+    expect(literal.typeArguments, isNull);
     Token leftBracket = literal.leftBracket;
     expect(leftBracket, isNotNull);
     expect(leftBracket.precedingComments, isNotNull);
@@ -5330,21 +5306,18 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseListLiteral_empty_twoTokens() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
-    TypeArgumentList typeArguments = null;
-    createParser('[ ]');
-    ListLiteral literal = parser.parseListLiteral(token, typeArguments);
+    ListLiteral literal = parseListLiteral(token, null, '[ ]');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.constKeyword, token);
-    expect(literal.typeArguments, typeArguments);
+    expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListLiteral_multiple() {
-    createParser('[1, 2, 3]');
-    ListLiteral literal = parser.parseListLiteral(null, null);
+    ListLiteral literal = parseListLiteral(null, null, '[1, 2, 3]');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.constKeyword, isNull);
@@ -5355,8 +5328,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseListLiteral_single() {
-    createParser('[1]');
-    ListLiteral literal = parser.parseListLiteral(null, null);
+    ListLiteral literal = parseListLiteral(null, null, '[1]');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.constKeyword, isNull);
@@ -5366,9 +5338,19 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
     expect(literal.rightBracket, isNotNull);
   }
 
+  void test_parseListLiteral_single_withTypeArgument() {
+    ListLiteral literal = parseListLiteral(null, '<int>', '[1]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword, isNull);
+    expect(literal.typeArguments, isNotNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(1));
+    expect(literal.rightBracket, isNotNull);
+  }
+
   void test_parseListOrMapLiteral_list_noType() {
-    createParser('[1]');
-    TypedLiteral literal = parser.parseListOrMapLiteral(null);
+    TypedLiteral literal = parseListOrMapLiteral(null, '[1]');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal, new isInstanceOf<ListLiteral>());
@@ -5381,8 +5363,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseListOrMapLiteral_list_type() {
-    createParser('<int> [1]');
-    TypedLiteral literal = parser.parseListOrMapLiteral(null);
+    TypedLiteral literal = parseListOrMapLiteral(null, '<int> [1]');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal, new isInstanceOf<ListLiteral>());
@@ -5395,8 +5376,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseListOrMapLiteral_map_noType() {
-    createParser("{'1' : 1}");
-    TypedLiteral literal = parser.parseListOrMapLiteral(null);
+    TypedLiteral literal = parseListOrMapLiteral(null, "{'1' : 1}");
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal, new isInstanceOf<MapLiteral>());
@@ -5409,8 +5389,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseListOrMapLiteral_map_type() {
-    createParser("<String, int> {'1' : 1}");
-    TypedLiteral literal = parser.parseListOrMapLiteral(null);
+    TypedLiteral literal =
+        parseListOrMapLiteral(null, "<String, int> {'1' : 1}");
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal, new isInstanceOf<MapLiteral>());
@@ -5423,8 +5403,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseLogicalAndExpression() {
-    createParser('x && y');
-    Expression expression = parser.parseLogicalAndExpression();
+    Expression expression = parseLogicalAndExpression('x && y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -5436,8 +5415,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseLogicalOrExpression() {
-    createParser('x || y');
-    Expression expression = parser.parseLogicalOrExpression();
+    Expression expression = parseLogicalOrExpression('x || y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -5450,22 +5428,18 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseMapLiteral_empty() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
-    TypeArgumentList typeArguments = AstTestFactory.typeArgumentList(
-        [AstTestFactory.typeName4("String"), AstTestFactory.typeName4("int")]);
-    createParser('{}');
-    MapLiteral literal = parser.parseMapLiteral(token, typeArguments);
+    MapLiteral literal = parseMapLiteral(token, '<String, int>', '{}');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.constKeyword, token);
-    expect(literal.typeArguments, typeArguments);
+    expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseMapLiteral_multiple() {
-    createParser("{'a' : b, 'x' : y}");
-    MapLiteral literal = parser.parseMapLiteral(null, null);
+    MapLiteral literal = parseMapLiteral(null, null, "{'a' : b, 'x' : y}");
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.leftBracket, isNotNull);
@@ -5474,8 +5448,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseMapLiteral_single() {
-    createParser("{'x' : y}");
-    MapLiteral literal = parser.parseMapLiteral(null, null);
+    MapLiteral literal = parseMapLiteral(null, null, "{'x' : y}");
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.leftBracket, isNotNull);
@@ -5484,8 +5457,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseMapLiteralEntry_complex() {
-    createParser('2 + 2 : y');
-    MapLiteralEntry entry = parser.parseMapLiteralEntry();
+    MapLiteralEntry entry = parseMapLiteralEntry('2 + 2 : y');
     expect(entry, isNotNull);
     assertNoErrors();
     expect(entry.key, isNotNull);
@@ -5494,8 +5466,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseMapLiteralEntry_int() {
-    createParser('0 : y');
-    MapLiteralEntry entry = parser.parseMapLiteralEntry();
+    MapLiteralEntry entry = parseMapLiteralEntry('0 : y');
     expect(entry, isNotNull);
     assertNoErrors();
     expect(entry.key, isNotNull);
@@ -5504,8 +5475,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseMapLiteralEntry_string() {
-    createParser("'x' : y");
-    MapLiteralEntry entry = parser.parseMapLiteralEntry();
+    MapLiteralEntry entry = parseMapLiteralEntry("'x' : y");
     expect(entry, isNotNull);
     assertNoErrors();
     expect(entry.key, isNotNull);
@@ -5514,8 +5484,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseMultiplicativeExpression_normal() {
-    createParser('x * y');
-    Expression expression = parser.parseMultiplicativeExpression();
+    Expression expression = parseMultiplicativeExpression('x * y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -5527,8 +5496,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseMultiplicativeExpression_super() {
-    createParser('super * y');
-    Expression expression = parser.parseMultiplicativeExpression();
+    Expression expression = parseMultiplicativeExpression('super * y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -5540,8 +5508,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseNewExpression() {
-    createParser('new A()');
-    InstanceCreationExpression expression = parser.parseNewExpression();
+    InstanceCreationExpression expression = parseNewExpression('new A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, isNotNull);
@@ -5554,8 +5521,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePostfixExpression_decrement() {
-    createParser('i--');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('i--');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PostfixExpression>());
@@ -5566,8 +5532,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePostfixExpression_increment() {
-    createParser('i++');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('i++');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PostfixExpression>());
@@ -5578,8 +5543,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePostfixExpression_none_indexExpression() {
-    createParser('a[0]');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a[0]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IndexExpression>());
@@ -5589,8 +5553,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePostfixExpression_none_methodInvocation() {
-    createParser('a.m()');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a.m()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5603,8 +5566,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePostfixExpression_none_methodInvocation_question_dot() {
-    createParser('a?.m()');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a?.m()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5619,8 +5581,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void
       test_parsePostfixExpression_none_methodInvocation_question_dot_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('a?.m/*<E>*/()');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a?.m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5634,8 +5595,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void
       test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
-    createParser('a?.m<E>()');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a?.m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5650,8 +5610,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void
       test_parsePostfixExpression_none_methodInvocation_typeArgumentComments() {
     enableGenericMethodComments = true;
-    createParser('a.m/*<E>*/()');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a.m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5664,8 +5623,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
-    createParser('a.m<E>()');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a.m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
@@ -5678,8 +5636,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePostfixExpression_none_propertyAccess() {
-    createParser('a.b');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('a.b');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PrefixedIdentifier>());
@@ -5690,8 +5647,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parsePrefixedIdentifier_noPrefix() {
     String lexeme = "bar";
-    createParser(lexeme);
-    Identifier identifier = parser.parsePrefixedIdentifier();
+    Identifier identifier = parsePrefixedIdentifier(lexeme);
     expect(identifier, isNotNull);
     assertNoErrors();
     expect(identifier, new isInstanceOf<SimpleIdentifier>());
@@ -5702,8 +5658,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parsePrefixedIdentifier_prefix() {
     String lexeme = "foo.bar";
-    createParser(lexeme);
-    Identifier identifier = parser.parsePrefixedIdentifier();
+    Identifier identifier = parsePrefixedIdentifier(lexeme);
     expect(identifier, isNotNull);
     assertNoErrors();
     expect(identifier, new isInstanceOf<PrefixedIdentifier>());
@@ -5714,8 +5669,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_const() {
-    createParser('const A()');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('const A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, isNotNull);
@@ -5723,8 +5677,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parsePrimaryExpression_double() {
     String doubleLiteral = "3.2e4";
-    createParser(doubleLiteral);
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression(doubleLiteral);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<DoubleLiteral>());
@@ -5734,8 +5687,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_false() {
-    createParser('false');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('false');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BooleanLiteral>());
@@ -5745,8 +5697,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_function_arguments() {
-    createParser('(int i) => i + 1');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('(int i) => i + 1');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpression>());
@@ -5756,8 +5707,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_function_noArguments() {
-    createParser('() => 42');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('() => 42');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpression>());
@@ -5767,8 +5717,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_genericFunctionExpression() {
-    createParser('<X, Y>(Map<X, Y> m, X x) => m[x]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression =
+        parsePrimaryExpression('<X, Y>(Map<X, Y> m, X x) => m[x]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpression>());
@@ -5778,8 +5728,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parsePrimaryExpression_hex() {
     String hexLiteral = "3F";
-    createParser('0x$hexLiteral');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('0x$hexLiteral');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IntegerLiteral>());
@@ -5789,8 +5738,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_identifier() {
-    createParser('a');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('a');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleIdentifier>());
@@ -5800,8 +5748,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parsePrimaryExpression_int() {
     String intLiteral = "472";
-    createParser(intLiteral);
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression(intLiteral);
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IntegerLiteral>());
@@ -5811,8 +5758,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_listLiteral() {
-    createParser('[ ]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
@@ -5821,8 +5767,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_listLiteral_index() {
-    createParser('[]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('[]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
@@ -5831,8 +5776,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_listLiteral_typed() {
-    createParser('<A>[ ]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('<A>[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
@@ -5843,8 +5787,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parsePrimaryExpression_listLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
-    createParser('/*<A>*/[ ]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('/*<A>*/[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
@@ -5854,8 +5797,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_mapLiteral() {
-    createParser('{}');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('{}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
@@ -5865,8 +5807,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_mapLiteral_typed() {
-    createParser('<A, B>{}');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('<A, B>{}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
@@ -5877,8 +5818,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parsePrimaryExpression_mapLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
-    createParser('/*<A, B>*/{}');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('/*<A, B>*/{}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
@@ -5888,8 +5828,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_new() {
-    createParser('new A()');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('new A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<InstanceCreationExpression>());
@@ -5898,8 +5837,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_null() {
-    createParser('null');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('null');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<NullLiteral>());
@@ -5908,8 +5846,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_parenthesized() {
-    createParser('(x)');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('(x)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ParenthesizedExpression>());
@@ -5918,8 +5855,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_string() {
-    createParser('"string"');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('"string"');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -5930,8 +5866,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_string_multiline() {
-    createParser("'''string'''");
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression("'''string'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -5942,8 +5877,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_string_raw() {
-    createParser("r'string'");
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression("r'string'");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -5954,8 +5888,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_super() {
-    createParser('super.x');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('super.x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
@@ -5967,8 +5900,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_this() {
-    createParser('this');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('this');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ThisExpression>());
@@ -5977,8 +5909,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parsePrimaryExpression_true() {
-    createParser('true');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('true');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BooleanLiteral>());
@@ -5988,8 +5919,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_as_functionType_noReturnType() {
-    createParser('x as Function(int)');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x as Function(int)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AsExpression>());
@@ -6000,8 +5930,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_as_functionType_returnType() {
-    createParser('x as String Function(int)');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression =
+        parseRelationalExpression('x as String Function(int)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AsExpression>());
@@ -6012,8 +5942,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_as_generic() {
-    createParser('x as C<D>');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x as C<D>');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AsExpression>());
@@ -6025,8 +5954,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseRelationalExpression_as_nullable() {
     enableNnbd = true;
-    createParser('x as Y?)');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x as Y?)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AsExpression>());
@@ -6037,8 +5965,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_as_simple() {
-    createParser('x as Y');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x as Y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AsExpression>());
@@ -6049,8 +5976,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_as_simple_function() {
-    createParser('x as Function');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x as Function');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AsExpression>());
@@ -6061,8 +5987,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_is() {
-    createParser('x is y');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x is y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IsExpression>());
@@ -6075,8 +6000,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseRelationalExpression_is_nullable() {
     enableNnbd = true;
-    createParser('x is y?)');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x is y?)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IsExpression>());
@@ -6088,8 +6012,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_isNot() {
-    createParser('x is! y');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x is! y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IsExpression>());
@@ -6101,8 +6024,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_normal() {
-    createParser('x < y');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('x < y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -6114,8 +6036,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRelationalExpression_super() {
-    createParser('super < y');
-    Expression expression = parser.parseRelationalExpression();
+    Expression expression = parseRelationalExpression('super < y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
@@ -6127,16 +6048,14 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseRethrowExpression() {
-    createParser('rethrow;');
-    RethrowExpression expression = parser.parseRethrowExpression();
+    RethrowExpression expression = parseRethrowExpression('rethrow');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.rethrowKeyword, isNotNull);
   }
 
   void test_parseShiftExpression_normal() {
-    createParser('x << y');
-    BinaryExpression expression = parser.parseShiftExpression();
+    BinaryExpression expression = parseShiftExpression('x << y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, isNotNull);
@@ -6146,8 +6065,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseShiftExpression_super() {
-    createParser('super << y');
-    BinaryExpression expression = parser.parseShiftExpression();
+    BinaryExpression expression = parseShiftExpression('super << y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, isNotNull);
@@ -6162,8 +6080,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseSimpleIdentifier_builtInIdentifier() {
     String lexeme = "as";
-    createParser(lexeme);
-    SimpleIdentifier identifier = parser.parseSimpleIdentifier();
+    SimpleIdentifier identifier = parseSimpleIdentifier(lexeme);
     expect(identifier, isNotNull);
     assertNoErrors();
     expect(identifier.token, isNotNull);
@@ -6172,8 +6089,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
 
   void test_parseSimpleIdentifier_normalIdentifier() {
     String lexeme = "foo";
-    createParser(lexeme);
-    SimpleIdentifier identifier = parser.parseSimpleIdentifier();
+    SimpleIdentifier identifier = parseSimpleIdentifier(lexeme);
     expect(identifier, isNotNull);
     assertNoErrors();
     expect(identifier.token, isNotNull);
@@ -6181,8 +6097,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_adjacent() {
-    createParser("'a' 'b'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'a' 'b'");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<AdjacentStrings>());
@@ -6196,8 +6111,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_endsWithInterpolation() {
-    createParser(r"'x$y'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral(r"'x$y'");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<StringInterpolation>());
@@ -6216,8 +6130,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_interpolated() {
-    createParser("'a \${b} c \$this d'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'a \${b} c \$this d'");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<StringInterpolation>());
@@ -6232,8 +6145,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_encodedSpace() {
-    createParser("'''\\x20\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\x20\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6243,8 +6155,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_endsWithInterpolation() {
-    createParser(r"'''x$y'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral(r"'''x$y'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<StringInterpolation>());
@@ -6263,8 +6174,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedBackslash() {
-    createParser("'''\\\\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6274,8 +6184,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedBackslash_raw() {
-    createParser("r'''\\\\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("r'''\\\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6285,8 +6194,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedEolMarker() {
-    createParser("'''\\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6296,8 +6204,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedEolMarker_raw() {
-    createParser("r'''\\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("r'''\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6307,8 +6214,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker() {
-    createParser("'''\\ \\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\ \\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6318,8 +6224,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker_raw() {
-    createParser("r'''\\ \\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("r'''\\ \\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6329,8 +6234,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedTab() {
-    createParser("'''\\t\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\t\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6340,8 +6244,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_escapedTab_raw() {
-    createParser("r'''\\t\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("r'''\\t\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6351,8 +6254,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_quoteAfterInterpolation() {
-    createParser(r"""'''$x'y'''""");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral(r"""'''$x'y'''""");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<StringInterpolation>());
@@ -6371,8 +6273,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_startsWithInterpolation() {
-    createParser(r"'''${x}y'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral(r"'''${x}y'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<StringInterpolation>());
@@ -6391,8 +6292,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_twoSpaces() {
-    createParser("'''  \na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''  \na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6402,8 +6302,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_twoSpaces_raw() {
-    createParser("r'''  \na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("r'''  \na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6413,8 +6312,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_multiline_untrimmed() {
-    createParser("''' a\nb'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("''' a\nb'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6424,8 +6322,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_quoteAfterInterpolation() {
-    createParser(r"""'$x"'""");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral(r"""'$x"'""");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<StringInterpolation>());
@@ -6444,8 +6341,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_single() {
-    createParser("'a'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'a'");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
@@ -6455,8 +6351,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseStringLiteral_startsWithInterpolation() {
-    createParser(r"'${x}y'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral(r"'${x}y'");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<StringInterpolation>());
@@ -6475,9 +6370,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseSuperConstructorInvocation_named() {
-    createParser('super.a()');
     SuperConstructorInvocation invocation =
-        parser.parseSuperConstructorInvocation();
+        parseSuperConstructorInvocation('super.a()');
     expect(invocation, isNotNull);
     assertNoErrors();
     expect(invocation.argumentList, isNotNull);
@@ -6487,9 +6381,8 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseSuperConstructorInvocation_unnamed() {
-    createParser('super()');
     SuperConstructorInvocation invocation =
-        parser.parseSuperConstructorInvocation();
+        parseSuperConstructorInvocation('super()');
     expect(invocation, isNotNull);
     assertNoErrors();
     expect(invocation.argumentList, isNotNull);
@@ -6499,8 +6392,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseSymbolLiteral_builtInIdentifier() {
-    createParser('#dynamic.static.abstract');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#dynamic.static.abstract');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
@@ -6512,8 +6404,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseSymbolLiteral_multiple() {
-    createParser('#a.b.c');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#a.b.c');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
@@ -6525,8 +6416,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseSymbolLiteral_operator() {
-    createParser('#==');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#==');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
@@ -6536,8 +6426,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseSymbolLiteral_single() {
-    createParser('#a');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#a');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
@@ -6547,8 +6436,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseSymbolLiteral_void() {
-    createParser('#void');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#void');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
@@ -6558,8 +6446,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseThrowExpression() {
-    createParser('throw x;');
-    Expression expression = parser.parseThrowExpression();
+    Expression expression = parseThrowExpression('throw x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ThrowExpression>());
@@ -6569,8 +6456,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseThrowExpressionWithoutCascade() {
-    createParser('throw x;');
-    Expression expression = parser.parseThrowExpressionWithoutCascade();
+    Expression expression = parseThrowExpressionWithoutCascade('throw x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ThrowExpression>());
@@ -6580,8 +6466,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_decrement_normal() {
-    createParser('--x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('--x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6590,8 +6475,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_decrement_super() {
-    createParser('--super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('--super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6606,8 +6490,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_decrement_super_propertyAccess() {
-    createParser('--super.x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('--super.x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6619,8 +6502,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_decrement_super_withComment() {
-    createParser('/* 0 */ --super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('/* 0 */ --super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6636,8 +6518,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_increment_normal() {
-    createParser('++x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('++x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6646,8 +6527,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_increment_super_index() {
-    createParser('++super[0]');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('++super[0]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6659,8 +6539,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_increment_super_propertyAccess() {
-    createParser('++super.x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('++super.x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6672,8 +6551,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_minus_normal() {
-    createParser('-x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('-x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6682,8 +6560,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_minus_super() {
-    createParser('-super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('-super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6692,8 +6569,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_not_normal() {
-    createParser('!x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('!x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6702,8 +6578,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_not_super() {
-    createParser('!super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('!super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6712,8 +6587,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_tilda_normal() {
-    createParser('~x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('~x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -6722,8 +6596,7 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   }
 
   void test_parseUnaryExpression_tilda_super() {
-    createParser('~super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('~super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
@@ -7985,6 +7858,57 @@ class ParserTestCase extends EngineTestCase
     }
   }
 
+  @override
+  Expression parseAdditiveExpression(String code) {
+    createParser(code);
+    return parser.parseAdditiveExpression();
+  }
+
+  @override
+  Expression parseAssignableExpression(String code, bool primaryAllowed) {
+    createParser(code);
+    return parser.parseAssignableExpression(primaryAllowed);
+  }
+
+  @override
+  Expression parseAssignableSelector(
+      String code, Expression prefix, bool optional,
+      {bool allowConditional: true}) {
+    createParser(code);
+    return parser.parseAssignableSelector(prefix, optional,
+        allowConditional: allowConditional);
+  }
+
+  @override
+  AwaitExpression parseAwaitExpression(String code) {
+    createParser(code);
+    return parser.parseAwaitExpression();
+  }
+
+  @override
+  Expression parseBitwiseAndExpression(String code) {
+    createParser(code);
+    return parser.parseBitwiseAndExpression();
+  }
+
+  @override
+  Expression parseBitwiseOrExpression(String code) {
+    createParser(code);
+    return parser.parseBitwiseOrExpression();
+  }
+
+  @override
+  Expression parseBitwiseXorExpression(String code) {
+    createParser(code);
+    return parser.parseBitwiseXorExpression();
+  }
+
+  @override
+  Expression parseCascadeSection(String code) {
+    createParser(code);
+    return parser.parseCascadeSection();
+  }
+
   /**
    * Parse the given source as a compilation unit.
    *
@@ -8037,6 +7961,18 @@ class ParserTestCase extends EngineTestCase
   }
 
   @override
+  ConditionalExpression parseConditionalExpression(String code) {
+    createParser(code);
+    return parser.parseConditionalExpression();
+  }
+
+  @override
+  Expression parseConstExpression(String code) {
+    createParser(code);
+    return parser.parseConstExpression();
+  }
+
+  @override
   CompilationUnit parseDirectives(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
@@ -8047,6 +7983,12 @@ class ParserTestCase extends EngineTestCase
     return unit;
   }
 
+  @override
+  BinaryExpression parseEqualityExpression(String code) {
+    createParser(code);
+    return parser.parseEqualityExpression();
+  }
+
   /**
    * Parse the given source as an expression.
    *
@@ -8066,6 +8008,18 @@ class ParserTestCase extends EngineTestCase
   }
 
   @override
+  List<Expression> parseExpressionList(String code) {
+    createParser(code);
+    return parser.parseExpressionList();
+  }
+
+  @override
+  Expression parseExpressionWithoutCascade(String code) {
+    createParser(code);
+    return parser.parseExpressionWithoutCascade();
+  }
+
+  @override
   FormalParameter parseFormalParameter(String code, ParameterKind kind,
       {List<ErrorCode> errorCodes: const <ErrorCode>[]}) {
     createParser(code);
@@ -8105,6 +8059,79 @@ class ParserTestCase extends EngineTestCase
           parser.parseCommentAndMetadata());
 
   @override
+  FunctionExpression parseFunctionExpression(String code) {
+    createParser(code);
+    return parser.parseFunctionExpression();
+  }
+
+  @override
+  InstanceCreationExpression parseInstanceCreationExpression(
+      String code, Token newToken) {
+    createParser(code);
+    return parser.parseInstanceCreationExpression(newToken);
+  }
+
+  @override
+  ListLiteral parseListLiteral(
+      Token token, String typeArgumentsCode, String code) {
+    TypeArgumentList typeArguments;
+    if (typeArgumentsCode != null) {
+      createParser(typeArgumentsCode);
+      typeArguments = parser.parseTypeArgumentList();
+    }
+    createParser(code);
+    return parser.parseListLiteral(token, typeArguments);
+  }
+
+  @override
+  TypedLiteral parseListOrMapLiteral(Token modifier, String code) {
+    createParser(code);
+    return parser.parseListOrMapLiteral(modifier);
+  }
+
+  @override
+  Expression parseLogicalAndExpression(String code) {
+    createParser(code);
+    return parser.parseLogicalAndExpression();
+  }
+
+  @override
+  Expression parseLogicalOrExpression(String code) {
+    createParser(code);
+    return parser.parseLogicalOrExpression();
+  }
+
+  @override
+  MapLiteral parseMapLiteral(
+      Token token, String typeArgumentsCode, String code) {
+    TypeArgumentList typeArguments;
+    if (typeArgumentsCode != null) {
+      createParser(typeArgumentsCode);
+      typeArguments = parser.parseTypeArgumentList();
+    }
+    createParser(code);
+    return parser.parseMapLiteral(token, typeArguments);
+  }
+
+  @override
+  MapLiteralEntry parseMapLiteralEntry(String code) {
+    createParser(code);
+    return parser.parseMapLiteralEntry();
+  }
+
+  @override
+  Expression parseMultiplicativeExpression(String code) {
+    createParser(code);
+    return parser.parseMultiplicativeExpression();
+  }
+
+  @override
+  InstanceCreationExpression parseNewExpression(String code) {
+    createParser(code);
+    return parser.parseNewExpression();
+  }
+
+  @override
   NormalFormalParameter parseNormalFormalParameter(String code,
       {bool inFunctionType: false,
       List<ErrorCode> errorCodes: const <ErrorCode>[]}) {
@@ -8115,6 +8142,48 @@ class ParserTestCase extends EngineTestCase
     return parameter;
   }
 
+  @override
+  Expression parsePostfixExpression(String code) {
+    createParser(code);
+    return parser.parsePostfixExpression();
+  }
+
+  @override
+  Identifier parsePrefixedIdentifier(String code) {
+    createParser(code);
+    return parser.parsePrefixedIdentifier();
+  }
+
+  @override
+  Expression parsePrimaryExpression(String code) {
+    createParser(code);
+    return parser.parsePrimaryExpression();
+  }
+
+  @override
+  Expression parseRelationalExpression(String code) {
+    createParser(code);
+    return parser.parseRelationalExpression();
+  }
+
+  @override
+  RethrowExpression parseRethrowExpression(String code) {
+    createParser(code);
+    return parser.parseRethrowExpression();
+  }
+
+  @override
+  BinaryExpression parseShiftExpression(String code) {
+    createParser(code);
+    return parser.parseShiftExpression();
+  }
+
+  @override
+  SimpleIdentifier parseSimpleIdentifier(String code) {
+    createParser(code);
+    return parser.parseSimpleIdentifier();
+  }
+
   /**
    * Parse the given [source] as a statement. The [errorCodes] are the error
    * codes of the errors that are expected to be found. If
@@ -8163,6 +8232,42 @@ class ParserTestCase extends EngineTestCase
   }
 
   @override
+  Expression parseStringLiteral(String code) {
+    createParser(code);
+    return parser.parseStringLiteral();
+  }
+
+  @override
+  SuperConstructorInvocation parseSuperConstructorInvocation(String code) {
+    createParser(code);
+    return parser.parseSuperConstructorInvocation();
+  }
+
+  @override
+  SymbolLiteral parseSymbolLiteral(String code) {
+    createParser(code);
+    return parser.parseSymbolLiteral();
+  }
+
+  @override
+  Expression parseThrowExpression(String code) {
+    createParser(code);
+    return parser.parseThrowExpression();
+  }
+
+  @override
+  Expression parseThrowExpressionWithoutCascade(String code) {
+    createParser(code);
+    return parser.parseThrowExpressionWithoutCascade();
+  }
+
+  @override
+  PrefixExpression parseUnaryExpression(String code) {
+    createParser(code);
+    return parser.parseUnaryExpression();
+  }
+
+  @override
   void setUp() {
     super.setUp();
     parseFunctionBodies = true;
@@ -9269,8 +9374,7 @@ class C {
   }
 
   void test_primaryExpression_argumentDefinitionTest() {
-    createParser('?a');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('?a');
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
     expect(expression, new isInstanceOf<SimpleIdentifier>());