Run ExpressionParserTestMixin tests with Fasta.

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 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';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ClassMemberParserTest);
@@ skipping 43 matching lines @@
   /**
    * Asserts that no errors occurred during parsing.
    */
   void assertNoErrors();
 
   /**
    * Prepares to parse using tokens scanned from the given [content] string.
    */
   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>[]]);
 
   /// TODO(paulberry): merge with [parseCompilationUnit]
   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.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the compilation unit that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   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>[]});
 
   FormalParameterList parseFormalParameterList(String code,
       {bool inFunctionType: false,
       List<ErrorCode> errorCodes: const <ErrorCode>[]});
 
   /**
    * Parses a single top level member of a compilation unit (other than a
    * directive), including any comment and/or metadata that precedes it.
    */
   CompilationUnitMember parseFullCompilationUnitMember();
 
   /**
    * Parses a single top level directive, including any comment and/or metadata
    * that precedes it.
    */
   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);
 }
 
 /**
  * Instances of the class `AstValidator` are used to validate the correct construction of an
  * AST structure.
  */
 class AstValidator extends UnifyingAstVisitor<Object> {
   /**
    * A list containing the errors found while traversing the AST structure.
    */
@@ skipping 2048 matching lines @@
   }
 
   @failingTest
   void test_expectedListOrMapLiteral() {
     // It isn't clear that this test can ever pass. The parser is currently
     // create a synthetic list literal in this case, but isSynthetic() isn't
     // overridden for ListLiteral. The problem is that the synthetic list
     // 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]);
     expect(literal.isSynthetic, isTrue);
   }
 
   void test_expectedStringLiteral() {
     createParser('1');
     StringLiteral literal = parser.parseStringLiteral();
     expectNotNullIfNoErrors(literal);
@@ skipping 477 matching lines @@
   }
 
   void test_invalidOperator() {
     createParser('void operator ===(x) {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_OPERATOR]);
   }
 
   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]);
   }
 
   void test_invalidOperatorForSuper() {
     createParser('++super');
     Expression expression = parser.parseUnaryExpression();
     expectNotNullIfNoErrors(expression);
     listener
         .assertErrorsWithCodes([ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
   }
 
   void test_invalidStarAfterAsync() {
     createParser('async* => 0;');
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_STAR_AFTER_ASYNC]);
   }
 
   void test_invalidSync() {
     createParser('sync* => 0;');
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_SYNC]);
   }
 
   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,
       ParserErrorCode.INVALID_CODE_POINT
     ]);
   }
 
   void test_libraryDirectiveNotFirst() {
     parseCompilationUnit("import 'x.dart'; library l;",
         [ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST]);
@@ skipping 284 matching lines @@
   }
 
   void test_missingIdentifier_inEnum() {
     createParser('enum E {, TWO}');
     EnumDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   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]);
   }
 
   void test_missingIdentifier_number() {
     createParser('1');
     SimpleIdentifier expression = parser.parseSimpleIdentifier();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(expression.isSynthetic, isTrue);
@@ skipping 215 matching lines @@
         [ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH]);
   }
 
   void test_multipleWithClauses() {
     parseCompilationUnit("class A extends B with C with D {}",
         [ParserErrorCode.MULTIPLE_WITH_CLAUSES]);
   }
 
   @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>());
   }
 
   void test_namedParameterOutsideGroup() {
     createParser('(a, b : 0)');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
     listener
@@ skipping 618 matching lines @@
         [ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 }
 
 @reflectiveTest
 class ExpressionParserTest extends ParserTestCase
     with ExpressionParserTestMixin {}
 
 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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.PLUS);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.PLUS);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     expect(invocation.typeArguments, isNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     IndexExpression indexExpression = expression;
     expect(indexExpression.target, isNotNull);
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     SimpleIdentifier identifier = expression;
     expect(identifier, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     expect(invocation.typeArguments, isNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     IndexExpression indexExpression = expression;
     expect(indexExpression.target, isNotNull);
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression,
         SuperExpression, propertyAccess.target);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     IndexExpression indexExpression = expression;
     expect(indexExpression.target, new isInstanceOf<SuperExpression>());
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   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>());
     IndexExpression indexExpression = expression;
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   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>());
     SimpleIdentifier identifier = expression;
     expect(identifier, isNotNull);
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAwaitExpression() {
-    createParser('await x;');
-    AwaitExpression expression = parser.parseAwaitExpression();
+    AwaitExpression expression = parseAwaitExpression('await x;');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.awaitKeyword, isNotNull);
     expect(expression.expression, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.AMPERSAND);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.AMPERSAND);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.BAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.BAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.CARET);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.CARET);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseCascadeSection_i() {
-    createParser('..[i]');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..[i]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<IndexExpression>());
     IndexExpression section = expression;
     expect(section.target, isNull);
     expect(section.leftBracket, isNotNull);
     expect(section.index, isNotNull);
     expect(section.rightBracket, isNotNull);
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation section = expression;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     MethodInvocation section = expression;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     MethodInvocation section = expression;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_p() {
-    createParser('..a');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..a');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
     PropertyAccess section = expression;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   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>());
     AssignmentExpression section = expression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     expect(rhs, isNotNull);
   }
 
   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>());
     AssignmentExpression section = expression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
   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>());
     AssignmentExpression section = expression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
   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>());
     AssignmentExpression section = expression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
   void test_parseCascadeSection_p_builtIn() {
-    createParser('..as');
-    Expression expression = parser.parseCascadeSection();
+    Expression expression = parseCascadeSection('..as');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
     PropertyAccess section = expression;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   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>());
     MethodInvocation section = expression;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     MethodInvocation section = expression;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     MethodInvocation section = expression;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   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>());
     PropertyAccess section = expression;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess section = expression;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   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>());
     PropertyAccess section = expression;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   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);
     expect(expression.question, isNotNull);
     expect(expression.thenExpression, isNotNull);
     expect(expression.colon, isNotNull);
     expect(expression.elseExpression, isNotNull);
   }
 
   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>());
     InstanceCreationExpression instanceCreation = expression;
     expect(instanceCreation.keyword, isNotNull);
     ConstructorName name = instanceCreation.constructorName;
     expect(name, isNotNull);
     expect(name.type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(instanceCreation.argumentList, isNotNull);
   }
 
   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>());
     ListLiteral literal = expression;
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   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>());
     ListLiteral literal = expression;
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_untyped() {
-    createParser('const []');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const []');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
     ListLiteral literal = expression;
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   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>());
     MapLiteral literal = expression;
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNotNull);
   }
 
   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>());
     MapLiteral literal = expression;
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_untyped() {
-    createParser('const {}');
-    Expression expression = parser.parseConstExpression();
+    Expression expression = parseConstExpression('const {}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
     MapLiteral literal = expression;
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNull);
   }
 
   void test_parseEqualityExpression_normal() {
-    createParser('x == y');
-    BinaryExpression expression = parser.parseEqualityExpression();
+    BinaryExpression expression = parseEqualityExpression('x == y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
   }
 
   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>());
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseExpression_assign() {
     // TODO(brianwilkerson) Implement more tests for this method.
@@ skipping 116 matching lines @@
     Expression expression = parseExpression('super.m<E>()');
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   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));
   }
 
   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>());
     AssignmentExpression assignmentExpression = expression;
     expect(assignmentExpression.leftHandSide, isNotNull);
     expect(assignmentExpression.operator, isNotNull);
     expect(assignmentExpression.operator.type, TokenType.EQ);
     expect(assignmentExpression.rightHandSide, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.EQ_EQ);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   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);
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
   }
 
   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);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
     SimpleFormalParameter p = expression.parameters.parameters[0];
     expect(p.type, isNotNull);
   }
 
   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);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments, isNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments, isNull);
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void
       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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void
       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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments, isNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments, isNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   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);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
     NodeList<TypeAnnotation> arguments = type.typeArguments.arguments;
     expect(arguments, hasLength(1));
     expect((arguments[0] as TypeName).question, isNotNull);
   }
 
   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);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   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);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(3));
     expect(literal.rightBracket, isNotNull);
   }
 
   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);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(1));
     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>());
     ListLiteral listLiteral = literal;
     expect(listLiteral.constKeyword, isNull);
     expect(listLiteral.typeArguments, isNull);
     expect(listLiteral.leftBracket, isNotNull);
     expect(listLiteral.elements, hasLength(1));
     expect(listLiteral.rightBracket, isNotNull);
   }
 
   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>());
     ListLiteral listLiteral = literal;
     expect(listLiteral.constKeyword, isNull);
     expect(listLiteral.typeArguments, isNotNull);
     expect(listLiteral.leftBracket, isNotNull);
     expect(listLiteral.elements, hasLength(1));
     expect(listLiteral.rightBracket, isNotNull);
   }
 
   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>());
     MapLiteral mapLiteral = literal;
     expect(mapLiteral.constKeyword, isNull);
     expect(mapLiteral.typeArguments, isNull);
     expect(mapLiteral.leftBracket, isNotNull);
     expect(mapLiteral.entries, hasLength(1));
     expect(mapLiteral.rightBracket, isNotNull);
   }
 
   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>());
     MapLiteral mapLiteral = literal;
     expect(mapLiteral.constKeyword, isNull);
     expect(mapLiteral.typeArguments, isNotNull);
     expect(mapLiteral.leftBracket, isNotNull);
     expect(mapLiteral.entries, hasLength(1));
     expect(mapLiteral.rightBracket, isNotNull);
   }
 
   void test_parseLogicalAndExpression() {
-    createParser('x && y');
-    Expression expression = parser.parseLogicalAndExpression();
+    Expression expression = parseLogicalAndExpression('x && y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.AMPERSAND_AMPERSAND);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseLogicalOrExpression() {
-    createParser('x || y');
-    Expression expression = parser.parseLogicalOrExpression();
+    Expression expression = parseLogicalOrExpression('x || y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BinaryExpression>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.BAR_BAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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);
     expect(literal.entries, hasLength(2));
     expect(literal.rightBracket, isNotNull);
   }
 
   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);
     expect(literal.entries, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   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);
     expect(entry.separator, isNotNull);
     expect(entry.value, isNotNull);
   }
 
   void test_parseMapLiteralEntry_int() {
-    createParser('0 : y');
-    MapLiteralEntry entry = parser.parseMapLiteralEntry();
+    MapLiteralEntry entry = parseMapLiteralEntry('0 : y');
     expect(entry, isNotNull);
     assertNoErrors();
     expect(entry.key, isNotNull);
     expect(entry.separator, isNotNull);
     expect(entry.value, isNotNull);
   }
 
   void test_parseMapLiteralEntry_string() {
-    createParser("'x' : y");
-    MapLiteralEntry entry = parser.parseMapLiteralEntry();
+    MapLiteralEntry entry = parseMapLiteralEntry("'x' : y");
     expect(entry, isNotNull);
     assertNoErrors();
     expect(entry.key, isNotNull);
     expect(entry.separator, isNotNull);
     expect(entry.value, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.STAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.STAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseNewExpression() {
-    createParser('new A()');
-    InstanceCreationExpression expression = parser.parseNewExpression();
+    InstanceCreationExpression expression = parseNewExpression('new A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, isNotNull);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     expect(name.type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_decrement() {
-    createParser('i--');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('i--');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PostfixExpression>());
     PostfixExpression postfixExpression = expression;
     expect(postfixExpression.operand, isNotNull);
     expect(postfixExpression.operator, isNotNull);
     expect(postfixExpression.operator.type, TokenType.MINUS_MINUS);
   }
 
   void test_parsePostfixExpression_increment() {
-    createParser('i++');
-    Expression expression = parser.parsePostfixExpression();
+    Expression expression = parsePostfixExpression('i++');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<PostfixExpression>());
     PostfixExpression postfixExpression = expression;
     expect(postfixExpression.operand, isNotNull);
     expect(postfixExpression.operator, isNotNull);
     expect(postfixExpression.operator.type, TokenType.PLUS_PLUS);
   }
 
   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>());
     IndexExpression indexExpression = expression;
     expect(indexExpression.target, isNotNull);
     expect(indexExpression.index, isNotNull);
   }
 
   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>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   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>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   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>());
     PrefixedIdentifier identifier = expression;
     expect(identifier.prefix, isNotNull);
     expect(identifier.identifier, isNotNull);
   }
 
   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>());
     SimpleIdentifier simpleIdentifier = identifier;
     expect(simpleIdentifier.token, isNotNull);
     expect(simpleIdentifier.name, lexeme);
   }
 
   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>());
     PrefixedIdentifier prefixedIdentifier = identifier;
     expect(prefixedIdentifier.prefix.name, "foo");
     expect(prefixedIdentifier.period, isNotNull);
     expect(prefixedIdentifier.identifier.name, "bar");
   }
 
   void test_parsePrimaryExpression_const() {
-    createParser('const A()');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('const A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, isNotNull);
   }
 
   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>());
     DoubleLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, double.parse(doubleLiteral));
   }
 
   void test_parsePrimaryExpression_false() {
-    createParser('false');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('false');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BooleanLiteral>());
     BooleanLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, isFalse);
   }
 
   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>());
     FunctionExpression functionExpression = expression;
     expect(functionExpression.parameters, isNotNull);
     expect(functionExpression.body, isNotNull);
   }
 
   void test_parsePrimaryExpression_function_noArguments() {
-    createParser('() => 42');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('() => 42');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpression>());
     FunctionExpression functionExpression = expression;
     expect(functionExpression.parameters, isNotNull);
     expect(functionExpression.body, isNotNull);
   }
 
   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>());
     FunctionExpression function = expression;
     expect(function.typeParameters, isNotNull);
   }
 
   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>());
     IntegerLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, int.parse(hexLiteral, radix: 16));
   }
 
   void test_parsePrimaryExpression_identifier() {
-    createParser('a');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('a');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleIdentifier>());
     SimpleIdentifier identifier = expression;
     expect(identifier, isNotNull);
   }
 
   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>());
     IntegerLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, int.parse(intLiteral));
   }
 
   void test_parsePrimaryExpression_listLiteral() {
-    createParser('[ ]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
     ListLiteral literal = expression;
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_listLiteral_index() {
-    createParser('[]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('[]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
     ListLiteral literal = expression;
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_listLiteral_typed() {
-    createParser('<A>[ ]');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('<A>[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ListLiteral>());
     ListLiteral literal = expression;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(1));
   }
 
   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>());
     ListLiteral literal = expression;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(1));
   }
 
   void test_parsePrimaryExpression_mapLiteral() {
-    createParser('{}');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('{}');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<MapLiteral>());
     MapLiteral literal = expression;
     expect(literal.typeArguments, isNull);
     expect(literal, isNotNull);
   }
 
   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>());
     MapLiteral literal = expression;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(2));
   }
 
   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>());
     MapLiteral literal = expression;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(2));
   }
 
   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>());
     InstanceCreationExpression creation = expression;
     expect(creation, isNotNull);
   }
 
   void test_parsePrimaryExpression_null() {
-    createParser('null');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('null');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<NullLiteral>());
     NullLiteral literal = expression;
     expect(literal.literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_parenthesized() {
-    createParser('(x)');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('(x)');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ParenthesizedExpression>());
     ParenthesizedExpression parens = expression;
     expect(parens, isNotNull);
   }
 
   void test_parsePrimaryExpression_string() {
-    createParser('"string"');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('"string"');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
     SimpleStringLiteral literal = expression;
     expect(literal.isMultiline, isFalse);
     expect(literal.isRaw, isFalse);
     expect(literal.value, "string");
   }
 
   void test_parsePrimaryExpression_string_multiline() {
-    createParser("'''string'''");
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression("'''string'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
     SimpleStringLiteral literal = expression;
     expect(literal.isMultiline, isTrue);
     expect(literal.isRaw, isFalse);
     expect(literal.value, "string");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.isMultiline, isFalse);
     expect(literal.isRaw, isTrue);
     expect(literal.value, "string");
   }
 
   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>());
     PropertyAccess propertyAccess = expression;
     expect(propertyAccess.target is SuperExpression, isTrue);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parsePrimaryExpression_this() {
-    createParser('this');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('this');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ThisExpression>());
     ThisExpression thisExpression = expression;
     expect(thisExpression.thisKeyword, isNotNull);
   }
 
   void test_parsePrimaryExpression_true() {
-    createParser('true');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression = parsePrimaryExpression('true');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<BooleanLiteral>());
     BooleanLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, isTrue);
   }
 
   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>());
     AsExpression asExpression = expression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<GenericFunctionType>());
   }
 
   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>());
     AsExpression asExpression = expression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<GenericFunctionType>());
   }
 
   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>());
     AsExpression asExpression = expression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   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>());
     AsExpression asExpression = expression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   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>());
     AsExpression asExpression = expression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   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>());
     AsExpression asExpression = expression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   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>());
     IsExpression isExpression = expression;
     expect(isExpression.expression, isNotNull);
     expect(isExpression.isOperator, isNotNull);
     expect(isExpression.notOperator, isNull);
     expect(isExpression.type, isNotNull);
   }
 
   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>());
     IsExpression isExpression = expression;
     expect(isExpression.expression, isNotNull);
     expect(isExpression.isOperator, isNotNull);
     expect(isExpression.notOperator, isNull);
     expect(isExpression.type, isNotNull);
   }
 
   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>());
     IsExpression isExpression = expression;
     expect(isExpression.expression, isNotNull);
     expect(isExpression.isOperator, isNotNull);
     expect(isExpression.notOperator, isNotNull);
     expect(isExpression.type, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.LT);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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>());
     BinaryExpression binaryExpression = expression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.LT);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   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);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.LT_LT);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseShiftExpression_super() {
-    createParser('super << y');
-    BinaryExpression expression = parser.parseShiftExpression();
+    BinaryExpression expression = parseShiftExpression('super << y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.LT_LT);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseSimpleIdentifier1_normalIdentifier() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
   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);
     expect(identifier.name, lexeme);
   }
 
   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);
     expect(identifier.name, lexeme);
   }
 
   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>());
     AdjacentStrings literal = expression;
     NodeList<StringLiteral> strings = literal.strings;
     expect(strings, hasLength(2));
     StringLiteral firstString = strings[0];
     StringLiteral secondString = strings[1];
     expect((firstString as SimpleStringLiteral).value, "a");
     expect((secondString as SimpleStringLiteral).value, "b");
   }
 
   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>());
     StringInterpolation interpolation = expression;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, 'x');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '');
   }
 
   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>());
     StringInterpolation literal = expression;
     NodeList<InterpolationElement> elements = literal.elements;
     expect(elements, hasLength(5));
     expect(elements[0] is InterpolationString, isTrue);
     expect(elements[1] is InterpolationExpression, isTrue);
     expect(elements[2] is InterpolationString, isTrue);
     expect(elements[3] is InterpolationExpression, isTrue);
     expect(elements[4] is InterpolationString, isTrue);
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, " \na");
   }
 
   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>());
     StringInterpolation interpolation = expression;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, 'x');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '');
   }
 
   void test_parseStringLiteral_multiline_escapedBackslash() {
-    createParser("'''\\\\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\\na");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\\\\na");
   }
 
   void test_parseStringLiteral_multiline_escapedEolMarker() {
-    createParser("'''\\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker() {
-    createParser("'''\\ \\\na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''\\ \\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\t\na");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\t\na");
   }
 
   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>());
     StringInterpolation interpolation = expression;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, "'y");
   }
 
   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>());
     StringInterpolation interpolation = expression;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, 'y');
   }
 
   void test_parseStringLiteral_multiline_twoSpaces() {
-    createParser("'''  \na'''");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'''  \na'''");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   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>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, " a\nb");
   }
 
   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>());
     StringInterpolation interpolation = expression;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '"');
   }
 
   void test_parseStringLiteral_single() {
-    createParser("'a'");
-    Expression expression = parser.parseStringLiteral();
+    Expression expression = parseStringLiteral("'a'");
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<SimpleStringLiteral>());
     SimpleStringLiteral literal = expression;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   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>());
     StringInterpolation interpolation = expression;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, 'y');
   }
 
   void test_parseSuperConstructorInvocation_named() {
-    createParser('super.a()');
     SuperConstructorInvocation invocation =
-        parser.parseSuperConstructorInvocation();
+        parseSuperConstructorInvocation('super.a()');
     expect(invocation, isNotNull);
     assertNoErrors();
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNotNull);
     expect(invocation.superKeyword, isNotNull);
     expect(invocation.period, isNotNull);
   }
 
   void test_parseSuperConstructorInvocation_unnamed() {
-    createParser('super()');
     SuperConstructorInvocation invocation =
-        parser.parseSuperConstructorInvocation();
+        parseSuperConstructorInvocation('super()');
     expect(invocation, isNotNull);
     assertNoErrors();
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNull);
     expect(invocation.superKeyword, isNotNull);
     expect(invocation.period, isNull);
   }
 
   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);
     List<Token> components = literal.components;
     expect(components, hasLength(3));
     expect(components[0].lexeme, "dynamic");
     expect(components[1].lexeme, "static");
     expect(components[2].lexeme, "abstract");
   }
 
   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);
     List<Token> components = literal.components;
     expect(components, hasLength(3));
     expect(components[0].lexeme, "a");
     expect(components[1].lexeme, "b");
     expect(components[2].lexeme, "c");
   }
 
   void test_parseSymbolLiteral_operator() {
-    createParser('#==');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#==');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
     expect(components, hasLength(1));
     expect(components[0].lexeme, "==");
   }
 
   void test_parseSymbolLiteral_single() {
-    createParser('#a');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#a');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
     expect(components, hasLength(1));
     expect(components[0].lexeme, "a");
   }
 
   void test_parseSymbolLiteral_void() {
-    createParser('#void');
-    SymbolLiteral literal = parser.parseSymbolLiteral();
+    SymbolLiteral literal = parseSymbolLiteral('#void');
     expect(literal, isNotNull);
     assertNoErrors();
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
     expect(components, hasLength(1));
     expect(components[0].lexeme, "void");
   }
 
   void test_parseThrowExpression() {
-    createParser('throw x;');
-    Expression expression = parser.parseThrowExpression();
+    Expression expression = parseThrowExpression('throw x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ThrowExpression>());
     ThrowExpression throwExpression = expression;
     expect(throwExpression.throwKeyword, isNotNull);
     expect(throwExpression.expression, isNotNull);
   }
 
   void test_parseThrowExpressionWithoutCascade() {
-    createParser('throw x;');
-    Expression expression = parser.parseThrowExpressionWithoutCascade();
+    Expression expression = parseThrowExpressionWithoutCascade('throw x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<ThrowExpression>());
     ThrowExpression throwExpression = expression;
     expect(throwExpression.throwKeyword, isNotNull);
     expect(throwExpression.expression, isNotNull);
   }
 
   void test_parseUnaryExpression_decrement_normal() {
-    createParser('--x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('--x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS_MINUS);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_decrement_super() {
-    createParser('--super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('--super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS);
     Expression innerExpression = expression.operand;
     expect(innerExpression, isNotNull);
     expect(innerExpression is PrefixExpression, isTrue);
     PrefixExpression operand = innerExpression as PrefixExpression;
     expect(operand.operator, isNotNull);
     expect(operand.operator.type, TokenType.MINUS);
     expect(operand.operand, isNotNull);
   }
 
   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);
     expect(expression.operator.type, TokenType.MINUS_MINUS);
     expect(expression.operand, isNotNull);
     PropertyAccess operand = expression.operand as PropertyAccess;
     expect(operand.target is SuperExpression, isTrue);
     expect(operand.propertyName.name, "x");
   }
 
   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);
     expect(expression.operator.type, TokenType.MINUS);
     expect(expression.operator.precedingComments, isNotNull);
     Expression innerExpression = expression.operand;
     expect(innerExpression, isNotNull);
     expect(innerExpression is PrefixExpression, isTrue);
     PrefixExpression operand = innerExpression as PrefixExpression;
     expect(operand.operator, isNotNull);
     expect(operand.operator.type, TokenType.MINUS);
     expect(operand.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_increment_normal() {
-    createParser('++x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('++x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.PLUS_PLUS);
     expect(expression.operand, isNotNull);
   }
 
   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);
     expect(expression.operator.type, TokenType.PLUS_PLUS);
     expect(expression.operand, isNotNull);
     IndexExpression operand = expression.operand as IndexExpression;
     expect(operand.realTarget is SuperExpression, isTrue);
     expect(operand.index is IntegerLiteral, isTrue);
   }
 
   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);
     expect(expression.operator.type, TokenType.PLUS_PLUS);
     expect(expression.operand, isNotNull);
     PropertyAccess operand = expression.operand as PropertyAccess;
     expect(operand.target is SuperExpression, isTrue);
     expect(operand.propertyName.name, "x");
   }
 
   void test_parseUnaryExpression_minus_normal() {
-    createParser('-x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('-x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_minus_super() {
-    createParser('-super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('-super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_not_normal() {
-    createParser('!x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('!x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.BANG);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_not_super() {
-    createParser('!super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('!super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.BANG);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_tilda_normal() {
-    createParser('~x');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('~x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.TILDE);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_tilda_super() {
-    createParser('~super');
-    PrefixExpression expression = parser.parseUnaryExpression();
+    PrefixExpression expression = parseUnaryExpression('~super');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.TILDE);
     expect(expression.operand, isNotNull);
   }
 }
 
 /**
  * Tests of the analyzer parser based on [FormalParameterParserTestMixin].
@@ skipping 1241 matching lines @@
     parser.enableUriInPartOf = enableUriInPartOf;
     parser.currentToken = tokenStream;
   }
 
   void expectNotNullIfNoErrors(Object result) {
     if (!listener.hasErrors) {
       expect(result, isNotNull);
     }
   }
 
+  @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.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the compilation unit that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   CompilationUnit parseCompilationUnit(String source,
@@ skipping 32 matching lines @@
   CompilationUnit parseCompilationUnitWithOptions(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     CompilationUnit unit = parser.parseCompilationUnit2();
     expect(unit, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 
   @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);
     CompilationUnit unit = parser.parseDirectives2();
     expect(unit, isNotNull);
     expect(unit.declarations, hasLength(0));
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 
+  @override
+  BinaryExpression parseEqualityExpression(String code) {
+    createParser(code);
+    return parser.parseEqualityExpression();
+  }
+
   /**
    * Parse the given source as an expression.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the expression that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   Expression parseExpression(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     Expression expression = parser.parseExpression2();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes(errorCodes);
     return expression;
   }
 
   @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);
     FormalParameter parameter = parser.parseFormalParameter(kind);
     assertErrorsWithCodes(errorCodes);
     return parameter;
   }
 
   @override
   FormalParameterList parseFormalParameterList(String code,
@@ skipping 19 matching lines @@
 
   /**
    * Parses a variable declaration list (equivalent to a variable declaration
    * statement, but without the final comma).
    */
   VariableDeclarationList parseFullVariableDeclarationList() =>
       parser.parseVariableDeclarationListAfterMetadata(
           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>[]}) {
     createParser(code);
     FormalParameter parameter =
         parser.parseNormalFormalParameter(inFunctionType: inFunctionType);
     assertErrorsWithCodes(errorCodes);
     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
    * [enableLazyAssignmentOperators] is `true`, then lazy assignment operators
    * should be enabled.
    */
   Statement parseStatement(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[],
       bool enableLazyAssignmentOperators]) {
     GatheringErrorListener listener = new GatheringErrorListener();
@@ skipping 28 matching lines @@
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     List<Statement> statements = parser.parseStatements(token);
     expect(statements, hasLength(expectedCount));
     listener.assertErrorsWithCodes(errorCodes);
     return statements;
   }
 
   @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;
   }
 }
 
 /**
  * Helper methods that aid in parser tests.
  *
  * Intended to be mixed in to parser test case classes.
@@ skipping 1086 matching lines @@
   void test_prefixExpression_missing_operand_minus() {
     PrefixExpression expression =
         parseExpression("-", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.operand);
     expect(expression.operand.isSynthetic, isTrue);
     expect(expression.operator.type, TokenType.MINUS);
   }
 
   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>());
   }
 
   void test_relationalExpression_missing_LHS() {
     IsExpression expression =
         parseExpression("is y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
         SimpleIdentifier, expression.expression);
@@ skipping 5341 matching lines @@
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 }