Characterize more test failures

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 2046 matching lines @@
   }
 }
 
 /**
  * The class `ErrorParserTest` defines parser tests that test the parsing
  * of code to ensure that errors are correctly reported,
  * and in some cases, not reported.
  */
 @reflectiveTest
 class ErrorParserTest extends ParserTestCase with ErrorParserTestMixin {
+  void test_missingIdentifier_number() {
+    createParser('1');
+    SimpleIdentifier expression = parser.parseSimpleIdentifier();
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.isSynthetic, isTrue);
+  }
+
   void test_nullableTypeInExtends() {
     enableNnbd = true;
     createParser('extends B?');
     ExtendsClause clause = parser.parseExtendsClause();
     expectNotNullIfNoErrors(clause);
     listener.assertErrorsWithCodes([ParserErrorCode.NULLABLE_TYPE_IN_EXTENDS]);
   }
 
   void test_nullableTypeInImplements() {
     enableNnbd = true;
@@ skipping 433 matching lines @@
   }
 
   void test_duplicatedModifier_var() {
     createParser('var var m;');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([ParserErrorCode.DUPLICATED_MODIFIER]);
   }
 
   void test_duplicateLabelInSwitchStatement() {
-    createParser('switch (e) {l1: case 0: break; l1: case 1: break;}');
-    SwitchStatement statement = parser.parseSwitchStatement();
+    SwitchStatement statement =
+        parseStatement('switch (e) {l1: case 0: break; l1: case 1: break;}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT]);
   }
 
   void test_emptyEnumBody() {
     createParser('enum E {}');
     EnumDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertErrorsWithCodes([ParserErrorCode.EMPTY_ENUM_BODY]);
@@ skipping 18 matching lines @@
     parseExpression(
         "1 == 2 != 3", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
   }
 
   void test_equalityCannotBeEqualityOperand_neq_eq() {
     parseExpression(
         "1 != 2 == 3", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
   }
 
   void test_expectedCaseOrDefault() {
-    createParser('switch (e) {break;}');
-    SwitchStatement statement = parser.parseSwitchStatement();
+    SwitchStatement statement = parseStatement('switch (e) {break;}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_CASE_OR_DEFAULT]);
   }
 
   void test_expectedClassMember_inClass_afterType() {
     createParser('heart 2 heart');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_CLASS_MEMBER]);
   }
@@ skipping 35 matching lines @@
 
   void test_expectedExecutable_topLevel_eof() {
     createParser('x');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(member);
     listener.assertErrors(
         [new AnalysisError(null, 0, 1, ParserErrorCode.EXPECTED_EXECUTABLE)]);
   }
 
   void test_expectedInterpolationIdentifier() {
-    createParser("'\$x\$'");
-    StringLiteral literal = parser.parseStringLiteral();
-    expectNotNullIfNoErrors(literal);
-    listener.assertErrorsWithCodes([
+    StringLiteral literal = parseExpression("'\$x\$'", [
       fe.Scanner.useFasta
           ? ScannerErrorCode.MISSING_IDENTIFIER
           : ParserErrorCode.MISSING_IDENTIFIER
     ]);
+    expectNotNullIfNoErrors(literal);
   }
 
   void test_expectedInterpolationIdentifier_emptyString() {
     // The scanner inserts an empty string token between the two $'s; we need to
     // make sure that the MISSING_IDENTIFIER error that is generated has a
     // nonzero width so that it will show up in the editor UI.
-    createParser("'\$\$foo'");
-    StringLiteral literal = parser.parseStringLiteral();
+    StringLiteral literal = parseExpression(
+        "'\$\$foo'",
+        fe.Scanner.useFasta
+            ? [ScannerErrorCode.MISSING_IDENTIFIER]
+            : [ParserErrorCode.MISSING_IDENTIFIER]);
     expectNotNullIfNoErrors(literal);
-    listener.assertErrors(fe.Scanner.useFasta
-        ? [new AnalysisError(null, 2, 1, ScannerErrorCode.MISSING_IDENTIFIER)]
-        : [new AnalysisError(null, 2, 1, ParserErrorCode.MISSING_IDENTIFIER)]);
   }
 
   @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().
     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();
+    StringLiteral literal = parseStringLiteral('1');
     expectNotNullIfNoErrors(literal);
     listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_STRING_LITERAL]);
     expect(literal.isSynthetic, isTrue);
   }
 
   void test_expectedToken_commaMissingInArgumentList() {
     createParser('(x, y z)');
     ArgumentList list = parser.parseArgumentList();
     expectNotNullIfNoErrors(list);
     listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TOKEN]);
@@ skipping 429 matching lines @@
     parseCompilationUnit("class A extends B implements C with D {}",
         [ParserErrorCode.IMPLEMENTS_BEFORE_WITH]);
   }
 
   void test_importDirectiveAfterPartDirective() {
     parseCompilationUnit("part 'a.dart'; import 'b.dart';",
         [ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE]);
   }
 
   void test_initializedVariableInForEach() {
-    createParser('for (int a = 0 in foo) {}');
-    Statement statement = parser.parseForStatement();
+    Statement statement = parseStatement('for (int a = 0 in foo) {}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH]);
   }
 
   void test_invalidAwaitInFor() {
-    createParser('await for (; ;) {}');
-    Statement statement = parser.parseForStatement();
+    Statement statement = parseStatement('await for (; ;) {}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_AWAIT_IN_FOR]);
   }
 
   void test_invalidCodePoint() {
-    createParser("'\\u{110000}'");
-    StringLiteral literal = parser.parseStringLiteral();
+    StringLiteral literal =
+        parseExpression("'\\u{110000}'", [ParserErrorCode.INVALID_CODE_POINT]);
     expectNotNullIfNoErrors(literal);
-    listener.assertErrorsWithCodes([ParserErrorCode.INVALID_CODE_POINT]);
   }
 
   @failingTest
   void test_invalidCommentReference__new_nonIdentifier() {
     // This test fails because the method parseCommentReference returns null.
     createParser('');
     CommentReference reference = parser.parseCommentReference('new 42', 0);
     expectNotNullIfNoErrors(reference);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_COMMENT_REFERENCE]);
   }
@@ skipping 24 matching lines @@
   }
 
   void test_invalidConstructorName_with() {
     createParser("C.with();");
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_CONSTRUCTOR_NAME]);
   }
 
   void test_invalidHexEscape_invalidDigit() {
-    createParser("'\\x0 a'");
-    StringLiteral literal = parser.parseStringLiteral();
+    StringLiteral literal =
+        parseExpression("'\\x0 a'", [ParserErrorCode.INVALID_HEX_ESCAPE]);
     expectNotNullIfNoErrors(literal);
-    listener.assertErrorsWithCodes([ParserErrorCode.INVALID_HEX_ESCAPE]);
   }
 
   void test_invalidHexEscape_tooFewDigits() {
-    createParser("'\\x0'");
-    StringLiteral literal = parser.parseStringLiteral();
+    StringLiteral literal =
+        parseExpression("'\\x0'", [ParserErrorCode.INVALID_HEX_ESCAPE]);
     expectNotNullIfNoErrors(literal);
-    listener.assertErrorsWithCodes([ParserErrorCode.INVALID_HEX_ESCAPE]);
   }
 
   void test_invalidInterpolationIdentifier_startWithDigit() {
-    createParser("'\$1'");
-    StringLiteral literal = parser.parseStringLiteral();
-    expectNotNullIfNoErrors(literal);
-    listener.assertErrorsWithCodes([
+    StringLiteral literal = parseExpression("'\$1'", [
       fe.Scanner.useFasta
           ? ScannerErrorCode.MISSING_IDENTIFIER
           : ParserErrorCode.MISSING_IDENTIFIER
     ]);
+    expectNotNullIfNoErrors(literal);
   }
 
   void test_invalidLiteralInConfiguration() {
     createParser("if (a == 'x \$y z') 'a.dart'");
     Configuration configuration = parser.parseConfiguration();
     expectNotNullIfNoErrors(configuration);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.INVALID_LITERAL_IN_CONFIGURATION]);
   }
 
@@ skipping 230 matching lines @@
 
   void test_missingAssignableSelector_prefix_plusPlus_literal() {
     parseExpression("++0", [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
   }
 
   void test_missingAssignableSelector_selector() {
     parseExpression("x(y)(z).a++");
   }
 
   void test_missingAssignableSelector_superPrimaryExpression() {
-    createParser('super');
-    Expression expression = parser.parsePrimaryExpression();
+    Expression expression =
+        parseExpression('super', [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
     expectNotNullIfNoErrors(expression);
-    listener
-        .assertErrorsWithCodes([ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
     expect(expression, new isInstanceOf<SuperExpression>());
     SuperExpression superExpression = expression;
     expect(superExpression.superKeyword, isNotNull);
   }
 
   void test_missingAssignableSelector_superPropertyAccessAssigned() {
     parseExpression("super.x = x;");
   }
 
   void test_missingCatchOrFinally() {
-    createParser('try {}');
-    TryStatement statement = parser.parseTryStatement();
+    TryStatement statement = parseStatement('try {}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_CATCH_OR_FINALLY]);
     expect(statement, isNotNull);
   }
 
   void test_missingClassBody() {
     parseCompilationUnit(
         "class A class B {}", [ParserErrorCode.MISSING_CLASS_BODY]);
   }
 
@@ skipping 25 matching lines @@
         [ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE]);
   }
 
   void test_missingEnumBody() {
     createParser('enum E;');
     EnumDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_ENUM_BODY]);
   }
 
-  void test_missingExpressionInThrow_withCascade() {
-    createParser('throw;');
-    ThrowExpression expression = parser.parseThrowExpression();
+  void test_missingExpressionInThrow() {
+    ThrowExpression expression =
+        (parseStatement('throw;') as ExpressionStatement).expression;
     expectNotNullIfNoErrors(expression);
     listener
         .assertErrorsWithCodes([ParserErrorCode.MISSING_EXPRESSION_IN_THROW]);
-  }
-
-  void test_missingExpressionInThrow_withoutCascade() {
-    createParser('throw;');
-    ThrowExpression expression = parser.parseThrowExpressionWithoutCascade();
-    expectNotNullIfNoErrors(expression);
-    listener
-        .assertErrorsWithCodes([ParserErrorCode.MISSING_EXPRESSION_IN_THROW]);
   }
 
   void test_missingFunctionBody_emptyNotAllowed() {
     createParser(';');
     FunctionBody functionBody = parser.parseFunctionBody(
         false, ParserErrorCode.MISSING_FUNCTION_BODY, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_FUNCTION_BODY]);
   }
 
@@ skipping 84 matching lines @@
     expectNotNullIfNoErrors(literal);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_missingIdentifier_inSymbol_first() {
     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);
-  }
-
   void test_missingIdentifierForParameterGroup() {
     createParser('(,)');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_missingKeywordOperator() {
     createParser('+(x) {}');
     MethodDeclaration method = parser.parseClassMember('C');
@@ skipping 33 matching lines @@
   }
 
   void test_missingMethodParameters_void_expression() {
     createParser('void m => null; }');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_METHOD_PARAMETERS]);
   }
 
   void test_missingNameForNamedParameter_colon() {
-    createParser('int : 0');
+    createParser('({int : 0})');
     FormalParameter parameter =
-        parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
     expectNotNullIfNoErrors(parameter);
     listener.assertErrorsWithCodes([
       ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE,
       ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER
     ]);
     expect(parameter.identifier, isNotNull);
   }
 
   void test_missingNameForNamedParameter_equals() {
-    createParser('int = 0');
+    createParser('({int = 0})');
     FormalParameter parameter =
-        parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
     expectNotNullIfNoErrors(parameter);
     listener.assertErrorsWithCodes([
       ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE,
       ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER
     ]);
     expect(parameter.identifier, isNotNull);
   }
 
   void test_missingNameForNamedParameter_noDefault() {
-    createParser('int');
+    createParser('({int})');
     FormalParameter parameter =
-        parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
     expectNotNullIfNoErrors(parameter);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER]);
     expect(parameter.identifier, isNotNull);
   }
 
   void test_missingNameInLibraryDirective() {
     CompilationUnit unit = parseCompilationUnit(
         "library;", [ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE]);
     expect(unit, isNotNull);
@@ skipping 58 matching lines @@
     parseCompilationUnit(
         "typedef F<E>;", [ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
   }
 
   void test_missingTypedefParameters_void() {
     parseCompilationUnit(
         "typedef void F;", [ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
   }
 
   void test_missingVariableInForEach() {
-    createParser('for (a < b in foo) {}');
-    Statement statement = parser.parseForStatement();
+    Statement statement = parseStatement('for (a < b in foo) {}');
     expectNotNullIfNoErrors(statement);
     listener
         .assertErrorsWithCodes([ParserErrorCode.MISSING_VARIABLE_IN_FOR_EACH]);
   }
 
   void test_mixedParameterGroups_namedPositional() {
     createParser('(a, {b}, [c])');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
     listener.assertErrorsWithCodes([ParserErrorCode.MIXED_PARAMETER_GROUPS]);
@@ skipping 40 matching lines @@
 
   void test_multiplePositionalParameterGroups() {
     createParser('(a, [b], [c])');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.MULTIPLE_POSITIONAL_PARAMETER_GROUPS]);
   }
 
   void test_multipleVariablesInForEach() {
-    createParser('for (int a, b in foo) {}');
-    Statement statement = parser.parseForStatement();
+    Statement statement = parseStatement('for (int a, b in foo) {}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH]);
   }
 
   void test_multipleWithClauses() {
     parseCompilationUnit("class A extends B with C with D {}",
         [ParserErrorCode.MULTIPLE_WITH_CLAUSES]);
   }
 
@@ skipping 253 matching lines @@
                 ParserErrorCode.EXPECTED_TOKEN,
                 ParserErrorCode.EXPECTED_TOKEN,
                 ParserErrorCode.EXPECTED_TOKEN,
                 ParserErrorCode.EXPECTED_TOKEN,
                 ParserErrorCode.EXPECTED_TOKEN,
                 ParserErrorCode.EXPECTED_TOKEN,
               ]);
   }
 
   void test_switchHasCaseAfterDefaultCase() {
-    createParser('switch (a) {default: return 0; case 1: return 1;}');
-    SwitchStatement statement = parser.parseSwitchStatement();
+    SwitchStatement statement =
+        parseStatement('switch (a) {default: return 0; case 1: return 1;}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE]);
   }
 
   void test_switchHasCaseAfterDefaultCase_repeated() {
-    createParser(
+    SwitchStatement statement = parseStatement(
         'switch (a) {default: return 0; case 1: return 1; case 2: return 2;}');
-    SwitchStatement statement = parser.parseSwitchStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes([
       ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE,
       ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE
     ]);
   }
 
   void test_switchHasMultipleDefaultCases() {
-    createParser('switch (a) {default: return 0; default: return 1;}');
-    SwitchStatement statement = parser.parseSwitchStatement();
+    SwitchStatement statement =
+        parseStatement('switch (a) {default: return 0; default: return 1;}');
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES]);
   }
 
   void test_switchHasMultipleDefaultCases_repeated() {
-    createParser(
+    SwitchStatement statement = parseStatement(
         'switch (a) {default: return 0; default: return 1; default: return 2;}');
-    SwitchStatement statement = parser.parseSwitchStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes([
       ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES,
       ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES
     ]);
   }
 
   void test_topLevel_getter() {
     createParser('get x => 7;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
@@ skipping 240 matching lines @@
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([ParserErrorCode.VAR_RETURN_TYPE]);
   }
 
   void test_varTypedef() {
     parseCompilationUnit("var typedef F();", [ParserErrorCode.VAR_TYPEDEF]);
   }
 
   void test_voidParameter() {
-    createParser('void a)');
-    NormalFormalParameter parameter = parser.parseNormalFormalParameter();
+    NormalFormalParameter parameter =
+        parseFormalParameterList('(void a)').parameters[0];
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
   }
 
   void test_voidVariable_parseClassMember_initializer() {
     createParser('void x = 0;');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
   }
@@ skipping 10992 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }