Add simple tests for Fasta parser

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
@@ skipping 8710 matching lines @@
   /**
    * Parse the given [source] as a statement. If [enableLazyAssignmentOperators]
    * is `true`, then lazy assignment operators should be enabled.
    */
   Statement parseStatement(String source,
       [bool enableLazyAssignmentOperators]) {
     listener = new GatheringErrorListener();
     Scanner scanner =
         new Scanner(null, new CharSequenceReader(source), listener);
     scanner.scanGenericMethodComments = enableGenericMethodComments;
-    scanner.scanLazyAssignmentOperators = enableLazyAssignmentOperators;
+    if (enableLazyAssignmentOperators != null) {
+      scanner.scanLazyAssignmentOperators = enableLazyAssignmentOperators;
+    }
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     parser.parseGenericMethodComments = enableGenericMethodComments;
     Statement statement = parser.parseStatement(token);
     expect(statement, isNotNull);
     return statement;
   }
 
   /**
@@ skipping 84 matching lines @@
     expect(components, hasLength(count));
     for (int i = 0; i < count; i++) {
       SimpleIdentifier component = components[i];
       expect(component, isNotNull);
       expect(component.name, expectedComponents[i]);
     }
   }
 }
 
 /**
+ * Tests of the analyzer parser based on [RecoveryParserTestMixin].
+ */
+@reflectiveTest
+class RecoveryParserTest extends ParserTestCase with RecoveryParserTestMixin {}
+
+/**
  * The class `RecoveryParserTest` defines parser tests that test the parsing of
  * invalid code sequences to ensure that the correct recovery steps are taken in
  * the parser.
  */
-@reflectiveTest
-class RecoveryParserTest extends ParserTestCase with RecoveryParserTestMixin {}
-
 abstract class RecoveryParserTestMixin implements AbstractParserTestCase {
   void test_additiveExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("+ y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
         SimpleIdentifier, expression.leftOperand);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
   void test_additiveExpression_missing_LHS_RHS() {
@@ skipping 1176 matching lines @@
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionTypeAlias, FunctionTypeAlias, member);
   }
 
   void test_unaryPlus() {
     parseExpression("+2", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 }
 
 /**
- * The class `SimpleParserTest` defines parser tests that test individual parsing method. The
- * code fragments should be as minimal as possible in order to test the method, but should not test
- * the interactions between the method under test and other methods.
- *
- * More complex tests should be defined in the class [ComplexParserTest].
+ * Tests of the analyzer parser based on [SimpleParserTestMixin].
  */
 @reflectiveTest
-class SimpleParserTest extends ParserTestCase {
+class SimpleParserTest extends ParserTestCase with SimpleParserTestMixin {
   void test_computeStringValue_emptyInterpolationPrefix() {
     expect(_computeStringValue("'''", true, false), "");
   }
 
   void test_computeStringValue_escape_b() {
     expect(_computeStringValue("'\\b'", true, true), "\b");
   }
 
   void test_computeStringValue_escape_f() {
     expect(_computeStringValue("'\\f'", true, true), "\f");
@@ skipping 268 matching lines @@
   }
 
   void test_isSwitchMember_default_unlabeled() {
     expect(_isSwitchMember("default"), isTrue);
   }
 
   void test_isSwitchMember_false() {
     expect(_isSwitchMember("break;"), isFalse);
   }
 
-  void test_parseAnnotation_n1() {
-    createParser('@A');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    listener.assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNull);
-  }
-
-  void test_parseAnnotation_n1_a() {
-    createParser('@A(x,y)');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    listener.assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNotNull);
-  }
-
-  void test_parseAnnotation_n2() {
-    createParser('@A.B');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    listener.assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNull);
-  }
-
-  void test_parseAnnotation_n2_a() {
-    createParser('@A.B(x,y)');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    listener.assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNotNull);
-  }
-
-  void test_parseAnnotation_n3() {
-    createParser('@A.B.C');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    listener.assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNotNull);
-    expect(annotation.constructorName, isNotNull);
-    expect(annotation.arguments, isNull);
-  }
-
-  void test_parseAnnotation_n3_a() {
-    createParser('@A.B.C(x,y)');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    listener.assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNotNull);
-    expect(annotation.constructorName, isNotNull);
-    expect(annotation.arguments, isNotNull);
-  }
-
-  void test_parseArgument_named() {
-    createParser('n: x');
-    Expression expression = parser.parseArgument();
-    expectNotNullIfNoErrors(expression);
-    listener.assertNoErrors();
-    expect(expression, new isInstanceOf<NamedExpression>());
-    NamedExpression namedExpression = expression;
-    Label name = namedExpression.name;
-    expect(name, isNotNull);
-    expect(name.label, isNotNull);
-    expect(name.colon, isNotNull);
-    expect(namedExpression.expression, isNotNull);
-  }
-
-  void test_parseArgument_unnamed() {
-    String lexeme = "x";
-    createParser(lexeme);
-    Expression expression = parser.parseArgument();
-    expectNotNullIfNoErrors(expression);
-    listener.assertNoErrors();
-    var identifier = expression as SimpleIdentifier;
-    expect(identifier.name, lexeme);
-  }
-
-  void test_parseArgumentList_empty() {
-    createParser('()');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    listener.assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(0));
-  }
-
-  void test_parseArgumentList_mixed() {
-    createParser('(w, x, y: y, z: z)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    listener.assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(4));
-  }
-
-  void test_parseArgumentList_noNamed() {
-    createParser('(x, y, z)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    listener.assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(3));
-  }
-
-  void test_parseArgumentList_onlyNamed() {
-    createParser('(x: x, y: y)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    listener.assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(2));
-  }
-
-  void test_parseArgumentList_trailing_comma() {
-    createParser('(x, y, z,)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    listener.assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(3));
-  }
-
-  void test_parseCombinator_hide() {
-    createParser('hide a;');
-    Combinator combinator = parser.parseCombinator();
-    expectNotNullIfNoErrors(combinator);
-    listener.assertNoErrors();
-    expect(combinator, new isInstanceOf<HideCombinator>());
-    HideCombinator hideCombinator = combinator;
-    expect(hideCombinator.keyword, isNotNull);
-    expect(hideCombinator.hiddenNames, hasLength(1));
-  }
-
-  void test_parseCombinator_show() {
-    createParser('show a;');
-    Combinator combinator = parser.parseCombinator();
-    expectNotNullIfNoErrors(combinator);
-    listener.assertNoErrors();
-    expect(combinator, new isInstanceOf<ShowCombinator>());
-    ShowCombinator showCombinator = combinator;
-    expect(showCombinator.keyword, isNotNull);
-    expect(showCombinator.shownNames, hasLength(1));
-  }
-
-  void test_parseCombinators_h() {
-    createParser('hide a;');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    listener.assertNoErrors();
-    expect(combinators, hasLength(1));
-    HideCombinator combinator = combinators[0] as HideCombinator;
-    expect(combinator, isNotNull);
-    expect(combinator.keyword, isNotNull);
-    expect(combinator.hiddenNames, hasLength(1));
-  }
-
-  void test_parseCombinators_hs() {
-    createParser('hide a show b;');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    listener.assertNoErrors();
-    expect(combinators, hasLength(2));
-    HideCombinator hideCombinator = combinators[0] as HideCombinator;
-    expect(hideCombinator, isNotNull);
-    expect(hideCombinator.keyword, isNotNull);
-    expect(hideCombinator.hiddenNames, hasLength(1));
-    ShowCombinator showCombinator = combinators[1] as ShowCombinator;
-    expect(showCombinator, isNotNull);
-    expect(showCombinator.keyword, isNotNull);
-    expect(showCombinator.shownNames, hasLength(1));
-  }
-
-  void test_parseCombinators_hshs() {
-    createParser('hide a show b hide c show d;');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    listener.assertNoErrors();
-    expect(combinators, hasLength(4));
-  }
-
-  void test_parseCombinators_s() {
-    createParser('show a;');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    listener.assertNoErrors();
-    expect(combinators, hasLength(1));
-    ShowCombinator combinator = combinators[0] as ShowCombinator;
-    expect(combinator, isNotNull);
-    expect(combinator.keyword, isNotNull);
-    expect(combinator.shownNames, hasLength(1));
-  }
-
-  void test_parseCommentAndMetadata_c() {
-    createParser('/** 1 */ void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNotNull);
-    expect(commentAndMetadata.metadata, isNull);
-  }
-
-  void test_parseCommentAndMetadata_cmc() {
-    createParser('/** 1 */ @A /** 2 */ void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNotNull);
-    expect(commentAndMetadata.metadata, hasLength(1));
-  }
-
-  void test_parseCommentAndMetadata_cmcm() {
-    createParser('/** 1 */ @A /** 2 */ @B void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNotNull);
-    expect(commentAndMetadata.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_cmm() {
-    createParser('/** 1 */ @A @B void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNotNull);
-    expect(commentAndMetadata.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_m() {
-    createParser('@A void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNull);
-    expect(commentAndMetadata.metadata, hasLength(1));
-  }
-
-  void test_parseCommentAndMetadata_mcm() {
-    createParser('@A /** 1 */ @B void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNotNull);
-    expect(commentAndMetadata.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_mcmc() {
-    createParser('@A /** 1 */ @B /** 2 */ void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNotNull);
-    expect(commentAndMetadata.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_mm() {
-    createParser('@A @B(x) void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNull);
-    expect(commentAndMetadata.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_none() {
-    createParser('void');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNull);
-    expect(commentAndMetadata.metadata, isNull);
-  }
-
-  void test_parseCommentAndMetadata_singleLine() {
-    createParser(r'''
-/// 1
-/// 2
-void''');
-    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
-    expectNotNullIfNoErrors(commentAndMetadata);
-    listener.assertNoErrors();
-    expect(commentAndMetadata.comment, isNotNull);
-    expect(commentAndMetadata.metadata, isNull);
-  }
-
   void test_parseCommentReference_new_prefixed() {
     createParser('');
     CommentReference reference = parser.parseCommentReference('new a.b', 7);
     expectNotNullIfNoErrors(reference);
     listener.assertNoErrors();
     expect(reference.identifier, new isInstanceOf<PrefixedIdentifier>());
     PrefixedIdentifier prefixedIdentifier = reference.identifier;
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     expect(prefix.token, isNotNull);
     expect(prefix.name, "a");
@@ skipping 417 matching lines @@
     List<CommentReference> references = parser.parseCommentReferences(tokens);
     expectNotNullIfNoErrors(references);
     listener.assertNoErrors();
     expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 15);
   }
 
+  void test_Parser() {
+    expect(new Parser(null, null), isNotNull);
+  }
+
+  void test_skipPrefixedIdentifier_invalid() {
+    createParser('+');
+    Token following = parser.skipPrefixedIdentifier(parser.currentToken);
+    expect(following, isNull);
+  }
+
+  void test_skipPrefixedIdentifier_notPrefixed() {
+    createParser('a +');
+    Token following = parser.skipPrefixedIdentifier(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipPrefixedIdentifier_prefixed() {
+    createParser('a.b +');
+    Token following = parser.skipPrefixedIdentifier(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipReturnType_invalid() {
+    // TODO(eernst): `skipReturnType` eliminated, delete this test?
+    createParser('+');
+    Token following = parser.skipTypeAnnotation(parser.currentToken);
+    expect(following, isNull);
+  }
+
+  void test_skipReturnType_type() {
+    // TODO(eernst): `skipReturnType` eliminated, delete this test?
+    createParser('C +');
+    Token following = parser.skipTypeAnnotation(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipReturnType_void() {
+    // TODO(eernst): `skipReturnType` eliminated, delete this test?
+    createParser('void +');
+    Token following = parser.skipTypeAnnotation(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipSimpleIdentifier_identifier() {
+    createParser('i +');
+    Token following = parser.skipSimpleIdentifier(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipSimpleIdentifier_invalid() {
+    createParser('9 +');
+    Token following = parser.skipSimpleIdentifier(parser.currentToken);
+    expect(following, isNull);
+  }
+
+  void test_skipSimpleIdentifier_pseudoKeyword() {
+    createParser('as +');
+    Token following = parser.skipSimpleIdentifier(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipStringLiteral_adjacent() {
+    createParser("'a' 'b' +");
+    Token following = parser.skipStringLiteral(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipStringLiteral_interpolated() {
+    createParser("'a\${b}c' +");
+    Token following = parser.skipStringLiteral(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipStringLiteral_invalid() {
+    createParser('a');
+    Token following = parser.skipStringLiteral(parser.currentToken);
+    expect(following, isNull);
+  }
+
+  void test_skipStringLiteral_single() {
+    createParser("'a' +");
+    Token following = parser.skipStringLiteral(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipTypeArgumentList_invalid() {
+    createParser('+');
+    Token following = parser.skipTypeArgumentList(parser.currentToken);
+    expect(following, isNull);
+  }
+
+  void test_skipTypeArgumentList_multiple() {
+    createParser('<E, F, G> +');
+    Token following = parser.skipTypeArgumentList(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipTypeArgumentList_single() {
+    createParser('<E> +');
+    Token following = parser.skipTypeArgumentList(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipTypeName_invalid() {
+    createParser('+');
+    Token following = parser.skipTypeName(parser.currentToken);
+    expect(following, isNull);
+  }
+
+  void test_skipTypeName_parameterized() {
+    createParser('C<E<F<G>>> +');
+    Token following = parser.skipTypeName(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  void test_skipTypeName_simple() {
+    createParser('C +');
+    Token following = parser.skipTypeName(parser.currentToken);
+    expect(following, isNotNull);
+    expect(following.type, TokenType.PLUS);
+  }
+
+  /**
+   * Invoke the method [Parser.computeStringValue] with the given argument.
+   *
+   * @param lexeme the argument to the method
+   * @param first `true` if this is the first token in a string literal
+   * @param last `true` if this is the last token in a string literal
+   * @return the result of invoking the method
+   * @throws Exception if the method could not be invoked or throws an exception
+   */
+  String _computeStringValue(String lexeme, bool first, bool last) {
+    createParser('');
+    String value = parser.computeStringValue(lexeme, first, last);
+    listener.assertNoErrors();
+    return value;
+  }
+
+  /**
+   * Invoke the method [Parser.isFunctionDeclaration] with the parser set to the token
+   * stream produced by scanning the given source.
+   *
+   * @param source the source to be scanned to produce the token stream being tested
+   * @return the result of invoking the method
+   * @throws Exception if the method could not be invoked or throws an exception
+   */
+  bool _isFunctionDeclaration(String source) {
+    createParser(source);
+    bool result = parser.isFunctionDeclaration();
+    expectNotNullIfNoErrors(result);
+    return result;
+  }
+
+  /**
+   * Invoke the method [Parser.isFunctionExpression] with the parser set to the token stream
+   * produced by scanning the given source.
+   *
+   * @param source the source to be scanned to produce the token stream being tested
+   * @return the result of invoking the method
+   * @throws Exception if the method could not be invoked or throws an exception
+   */
+  bool _isFunctionExpression(String source) {
+    createParser(source);
+    return parser.isFunctionExpression(parser.currentToken);
+  }
+
+  /**
+   * Invoke the method [Parser.isInitializedVariableDeclaration] with the parser set to the
+   * token stream produced by scanning the given source.
+   *
+   * @param source the source to be scanned to produce the token stream being tested
+   * @return the result of invoking the method
+   * @throws Exception if the method could not be invoked or throws an exception
+   */
+  bool _isInitializedVariableDeclaration(String source) {
+    createParser(source);
+    bool result = parser.isInitializedVariableDeclaration();
+    expectNotNullIfNoErrors(result);
+    return result;
+  }
+
+  /**
+   * Invoke the method [Parser.isSwitchMember] with the parser set to the token stream
+   * produced by scanning the given source.
+   *
+   * @param source the source to be scanned to produce the token stream being tested
+   * @return the result of invoking the method
+   * @throws Exception if the method could not be invoked or throws an exception
+   */
+  bool _isSwitchMember(String source) {
+    createParser(source);
+    bool result = parser.isSwitchMember();
+    expectNotNullIfNoErrors(result);
+    return result;
+  }
+}
+
+/**
+ * Parser tests that test individual parsing methods. The code fragments should
+ * be as minimal as possible in order to test the method, but should not test
+ * the interactions between the method under test and other methods.
+ *
+ * More complex tests should be defined in the class [ComplexParserTest].
+ */
+abstract class SimpleParserTestMixin implements AbstractParserTestCase {
+  /**
+   * Parse the given [content] as a sequence of statements by enclosing it in a
+   * block. The [expectedCount] is the number of statements that are expected to
+   * be parsed. If [errorCodes] are provided, verify that the error codes of the
+   * errors that are expected are found.
+   */
+  void parseStatementList(String content, int expectedCount) {
+    Statement statement = parseStatement('{$content}');
+    expect(statement, new isInstanceOf<Block>());
+    Block block = statement;
+    expect(block.statements, hasLength(expectedCount));
+  }
+
+  void test_parseAnnotation_n1() {
+    createParser('@A');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    listener.assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNull);
+  }
+
+  void test_parseAnnotation_n1_a() {
+    createParser('@A(x,y)');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    listener.assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNotNull);
+  }
+
+  void test_parseAnnotation_n2() {
+    createParser('@A.B');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    listener.assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNull);
+  }
+
+  void test_parseAnnotation_n2_a() {
+    createParser('@A.B(x,y)');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    listener.assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNotNull);
+  }
+
+  void test_parseAnnotation_n3() {
+    createParser('@A.B.C');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    listener.assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNotNull);
+    expect(annotation.constructorName, isNotNull);
+    expect(annotation.arguments, isNull);
+  }
+
+  void test_parseAnnotation_n3_a() {
+    createParser('@A.B.C(x,y)');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    listener.assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNotNull);
+    expect(annotation.constructorName, isNotNull);
+    expect(annotation.arguments, isNotNull);
+  }
+
+  void test_parseArgument_named() {
+    createParser('n: x');
+    Expression expression = parser.parseArgument();
+    expectNotNullIfNoErrors(expression);
+    listener.assertNoErrors();
+    expect(expression, new isInstanceOf<NamedExpression>());
+    NamedExpression namedExpression = expression;
+    Label name = namedExpression.name;
+    expect(name, isNotNull);
+    expect(name.label, isNotNull);
+    expect(name.colon, isNotNull);
+    expect(namedExpression.expression, isNotNull);
+  }
+
+  void test_parseArgument_unnamed() {
+    String lexeme = "x";
+    createParser(lexeme);
+    Expression expression = parser.parseArgument();
+    expectNotNullIfNoErrors(expression);
+    listener.assertNoErrors();
+    var identifier = expression as SimpleIdentifier;
+    expect(identifier.name, lexeme);
+  }
+
+  void test_parseArgumentList_empty() {
+    createParser('()');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    listener.assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(0));
+  }
+
+  void test_parseArgumentList_mixed() {
+    createParser('(w, x, y: y, z: z)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    listener.assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(4));
+  }
+
+  void test_parseArgumentList_noNamed() {
+    createParser('(x, y, z)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    listener.assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(3));
+  }
+
+  void test_parseArgumentList_onlyNamed() {
+    createParser('(x: x, y: y)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    listener.assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(2));
+  }
+
+  void test_parseArgumentList_trailing_comma() {
+    createParser('(x, y, z,)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    listener.assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(3));
+  }
+
+  void test_parseCombinator_hide() {
+    createParser('hide a;');
+    Combinator combinator = parser.parseCombinator();
+    expectNotNullIfNoErrors(combinator);
+    listener.assertNoErrors();
+    expect(combinator, new isInstanceOf<HideCombinator>());
+    HideCombinator hideCombinator = combinator;
+    expect(hideCombinator.keyword, isNotNull);
+    expect(hideCombinator.hiddenNames, hasLength(1));
+  }
+
+  void test_parseCombinator_show() {
+    createParser('show a;');
+    Combinator combinator = parser.parseCombinator();
+    expectNotNullIfNoErrors(combinator);
+    listener.assertNoErrors();
+    expect(combinator, new isInstanceOf<ShowCombinator>());
+    ShowCombinator showCombinator = combinator;
+    expect(showCombinator.keyword, isNotNull);
+    expect(showCombinator.shownNames, hasLength(1));
+  }
+
+  void test_parseCombinators_h() {
+    createParser('hide a;');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    listener.assertNoErrors();
+    expect(combinators, hasLength(1));
+    HideCombinator combinator = combinators[0] as HideCombinator;
+    expect(combinator, isNotNull);
+    expect(combinator.keyword, isNotNull);
+    expect(combinator.hiddenNames, hasLength(1));
+  }
+
+  void test_parseCombinators_hs() {
+    createParser('hide a show b;');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    listener.assertNoErrors();
+    expect(combinators, hasLength(2));
+    HideCombinator hideCombinator = combinators[0] as HideCombinator;
+    expect(hideCombinator, isNotNull);
+    expect(hideCombinator.keyword, isNotNull);
+    expect(hideCombinator.hiddenNames, hasLength(1));
+    ShowCombinator showCombinator = combinators[1] as ShowCombinator;
+    expect(showCombinator, isNotNull);
+    expect(showCombinator.keyword, isNotNull);
+    expect(showCombinator.shownNames, hasLength(1));
+  }
+
+  void test_parseCombinators_hshs() {
+    createParser('hide a show b hide c show d;');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    listener.assertNoErrors();
+    expect(combinators, hasLength(4));
+  }
+
+  void test_parseCombinators_s() {
+    createParser('show a;');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    listener.assertNoErrors();
+    expect(combinators, hasLength(1));
+    ShowCombinator combinator = combinators[0] as ShowCombinator;
+    expect(combinator, isNotNull);
+    expect(combinator.keyword, isNotNull);
+    expect(combinator.shownNames, hasLength(1));
+  }
+
+  void test_parseCommentAndMetadata_c() {
+    createParser('/** 1 */ void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNotNull);
+    expect(commentAndMetadata.metadata, isNull);
+  }
+
+  void test_parseCommentAndMetadata_cmc() {
+    createParser('/** 1 */ @A /** 2 */ void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNotNull);
+    expect(commentAndMetadata.metadata, hasLength(1));
+  }
+
+  void test_parseCommentAndMetadata_cmcm() {
+    createParser('/** 1 */ @A /** 2 */ @B void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNotNull);
+    expect(commentAndMetadata.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_cmm() {
+    createParser('/** 1 */ @A @B void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNotNull);
+    expect(commentAndMetadata.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_m() {
+    createParser('@A void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNull);
+    expect(commentAndMetadata.metadata, hasLength(1));
+  }
+
+  void test_parseCommentAndMetadata_mcm() {
+    createParser('@A /** 1 */ @B void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNotNull);
+    expect(commentAndMetadata.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_mcmc() {
+    createParser('@A /** 1 */ @B /** 2 */ void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNotNull);
+    expect(commentAndMetadata.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_mm() {
+    createParser('@A @B(x) void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNull);
+    expect(commentAndMetadata.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_none() {
+    createParser('void');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNull);
+    expect(commentAndMetadata.metadata, isNull);
+  }
+
+  void test_parseCommentAndMetadata_singleLine() {
+    createParser(r'''
+/// 1
+/// 2
+void''');
+    CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
+    expectNotNullIfNoErrors(commentAndMetadata);
+    listener.assertNoErrors();
+    expect(commentAndMetadata.comment, isNotNull);
+    expect(commentAndMetadata.metadata, isNull);
+  }
+
   void test_parseConfiguration_noOperator_dottedIdentifier() {
     createParser("if (a.b) 'c.dart'");
     Configuration configuration = parser.parseConfiguration();
     expectNotNullIfNoErrors(configuration);
     listener.assertNoErrors();
     expect(configuration.ifKeyword, isNotNull);
     expect(configuration.leftParenthesis, isNotNull);
     expectDottedName(configuration.name, ["a", "b"]);
     expect(configuration.equalToken, isNull);
     expect(configuration.value, isNull);
@@ skipping 36 matching lines @@
     listener.assertNoErrors();
     expect(configuration.ifKeyword, isNotNull);
     expect(configuration.leftParenthesis, isNotNull);
     expectDottedName(configuration.name, ["a"]);
     expect(configuration.equalToken, isNotNull);
     expect(configuration.value, isNotNull);
     expect(configuration.rightParenthesis, isNotNull);
     expect(configuration.uri, isNotNull);
   }
 
-  void test_parseConstructor() {
-    // TODO(brianwilkerson) Implement tests for this method.
-  }
-
   void test_parseConstructorName_named_noPrefix() {
     createParser('A.n;');
     ConstructorName name = parser.parseConstructorName();
     expectNotNullIfNoErrors(name);
     listener.assertNoErrors();
     expect(name.type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
   }
 
@@ skipping 536 matching lines @@
     Modifiers modifiers = parser.parseModifiers();
     expectNotNullIfNoErrors(modifiers);
     listener.assertNoErrors();
     expect(modifiers.varKeyword, isNotNull);
   }
 
   void test_parseOptionalReturnType() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
-  void test_Parser() {
-    expect(new Parser(null, null), isNotNull);
-  }
-
   void test_parseReturnStatement_noValue() {
     createParser('return;');
     ReturnStatement statement = parser.parseReturnStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement.returnKeyword, isNotNull);
     expect(statement.expression, isNull);
     expect(statement.semicolon, isNotNull);
   }
 
@@ skipping 46 matching lines @@
     expect(statement, new isInstanceOf<FunctionDeclarationStatement>());
     expect(
         (statement as FunctionDeclarationStatement)
             .functionDeclaration
             .functionExpression
             .body,
         new isInstanceOf<ExpressionFunctionBody>());
   }
 
   void test_parseStatements_multiple() {
-    List<Statement> statements = parseStatements("return; return;", 2);
-    expect(statements, hasLength(2));
+    parseStatementList("return; return;", 2);
   }
 
   void test_parseStatements_single() {
-    List<Statement> statements = parseStatements("return;", 1);
-    expect(statements, hasLength(1));
+    parseStatementList("return;", 1);
   }
 
   void test_parseTypeAnnotation_function_noReturnType_noParameters() {
     createParser('Function() v');
     GenericFunctionType functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
     expect(functionType.returnType, isNull);
     expect(functionType.functionKeyword, isNotNull);
     expect(functionType.typeParameters, isNull);
@@ skipping 439 matching lines @@
   }
 
   void test_parseWithClause_single() {
     createParser('with M');
     WithClause clause = parser.parseWithClause();
     expectNotNullIfNoErrors(clause);
     listener.assertNoErrors();
     expect(clause.withKeyword, isNotNull);
     expect(clause.mixinTypes, hasLength(1));
   }
-
-  void test_skipPrefixedIdentifier_invalid() {
-    createParser('+');
-    Token following = parser.skipPrefixedIdentifier(parser.currentToken);
-    expect(following, isNull);
-  }
-
-  void test_skipPrefixedIdentifier_notPrefixed() {
-    createParser('a +');
-    Token following = parser.skipPrefixedIdentifier(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipPrefixedIdentifier_prefixed() {
-    createParser('a.b +');
-    Token following = parser.skipPrefixedIdentifier(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipReturnType_invalid() {
-    // TODO(eernst): `skipReturnType` eliminated, delete this test?
-    createParser('+');
-    Token following = parser.skipTypeAnnotation(parser.currentToken);
-    expect(following, isNull);
-  }
-
-  void test_skipReturnType_type() {
-    // TODO(eernst): `skipReturnType` eliminated, delete this test?
-    createParser('C +');
-    Token following = parser.skipTypeAnnotation(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipReturnType_void() {
-    // TODO(eernst): `skipReturnType` eliminated, delete this test?
-    createParser('void +');
-    Token following = parser.skipTypeAnnotation(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipSimpleIdentifier_identifier() {
-    createParser('i +');
-    Token following = parser.skipSimpleIdentifier(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipSimpleIdentifier_invalid() {
-    createParser('9 +');
-    Token following = parser.skipSimpleIdentifier(parser.currentToken);
-    expect(following, isNull);
-  }
-
-  void test_skipSimpleIdentifier_pseudoKeyword() {
-    createParser('as +');
-    Token following = parser.skipSimpleIdentifier(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipStringLiteral_adjacent() {
-    createParser("'a' 'b' +");
-    Token following = parser.skipStringLiteral(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipStringLiteral_interpolated() {
-    createParser("'a\${b}c' +");
-    Token following = parser.skipStringLiteral(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipStringLiteral_invalid() {
-    createParser('a');
-    Token following = parser.skipStringLiteral(parser.currentToken);
-    expect(following, isNull);
-  }
-
-  void test_skipStringLiteral_single() {
-    createParser("'a' +");
-    Token following = parser.skipStringLiteral(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipTypeArgumentList_invalid() {
-    createParser('+');
-    Token following = parser.skipTypeArgumentList(parser.currentToken);
-    expect(following, isNull);
-  }
-
-  void test_skipTypeArgumentList_multiple() {
-    createParser('<E, F, G> +');
-    Token following = parser.skipTypeArgumentList(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipTypeArgumentList_single() {
-    createParser('<E> +');
-    Token following = parser.skipTypeArgumentList(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipTypeName_invalid() {
-    createParser('+');
-    Token following = parser.skipTypeName(parser.currentToken);
-    expect(following, isNull);
-  }
-
-  void test_skipTypeName_parameterized() {
-    createParser('C<E<F<G>>> +');
-    Token following = parser.skipTypeName(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  void test_skipTypeName_simple() {
-    createParser('C +');
-    Token following = parser.skipTypeName(parser.currentToken);
-    expect(following, isNotNull);
-    expect(following.type, TokenType.PLUS);
-  }
-
-  /**
-   * Invoke the method [Parser.computeStringValue] with the given argument.
-   *
-   * @param lexeme the argument to the method
-   * @param first `true` if this is the first token in a string literal
-   * @param last `true` if this is the last token in a string literal
-   * @return the result of invoking the method
-   * @throws Exception if the method could not be invoked or throws an exception
-   */
-  String _computeStringValue(String lexeme, bool first, bool last) {
-    createParser('');
-    String value = parser.computeStringValue(lexeme, first, last);
-    listener.assertNoErrors();
-    return value;
-  }
-
-  /**
-   * Invoke the method [Parser.isFunctionDeclaration] with the parser set to the token
-   * stream produced by scanning the given source.
-   *
-   * @param source the source to be scanned to produce the token stream being tested
-   * @return the result of invoking the method
-   * @throws Exception if the method could not be invoked or throws an exception
-   */
-  bool _isFunctionDeclaration(String source) {
-    createParser(source);
-    bool result = parser.isFunctionDeclaration();
-    expectNotNullIfNoErrors(result);
-    return result;
-  }
-
-  /**
-   * Invoke the method [Parser.isFunctionExpression] with the parser set to the token stream
-   * produced by scanning the given source.
-   *
-   * @param source the source to be scanned to produce the token stream being tested
-   * @return the result of invoking the method
-   * @throws Exception if the method could not be invoked or throws an exception
-   */
-  bool _isFunctionExpression(String source) {
-    createParser(source);
-    return parser.isFunctionExpression(parser.currentToken);
-  }
-
-  /**
-   * Invoke the method [Parser.isInitializedVariableDeclaration] with the parser set to the
-   * token stream produced by scanning the given source.
-   *
-   * @param source the source to be scanned to produce the token stream being tested
-   * @return the result of invoking the method
-   * @throws Exception if the method could not be invoked or throws an exception
-   */
-  bool _isInitializedVariableDeclaration(String source) {
-    createParser(source);
-    bool result = parser.isInitializedVariableDeclaration();
-    expectNotNullIfNoErrors(result);
-    return result;
-  }
-
-  /**
-   * Invoke the method [Parser.isSwitchMember] with the parser set to the token stream
-   * produced by scanning the given source.
-   *
-   * @param source the source to be scanned to produce the token stream being tested
-   * @return the result of invoking the method
-   * @throws Exception if the method could not be invoked or throws an exception
-   */
-  bool _isSwitchMember(String source) {
-    createParser(source);
-    bool result = parser.isSwitchMember();
-    expectNotNullIfNoErrors(result);
-    return result;
-  }
 }
 
 @reflectiveTest
 class StatementParserTest extends ParserTestCase with StatementParserTestMixin {
 }
 
 /**
  * The class [FormalParameterParserTestMixin] defines parser tests that test
  * the parsing statements.
  */
@@ skipping 3028 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }