New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/parser_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.parser_test;
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 3739 matching lines @@
   }
 
   /**
    * Invoke the method [Parser#computeStringValue] with the given argument.
    *
    * @param lexeme the argument to the method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   String computeStringValue(String lexeme) {
-    AnalysisErrorListener listener = new AnalysisErrorListener_20();
+    AnalysisErrorListener listener = new AnalysisErrorListener_21();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "computeStringValue", <Object> [lexeme], null) as String;
   }
 
   /**
    * Invoke the method [Parser#createSyntheticIdentifier] 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
@@ skipping 2187 matching lines @@
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_parameterized);
       });
       _ut.test('test_skipTypeName_simple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_simple);
       });
     });
   }
 }
-class AnalysisErrorListener_20 implements AnalysisErrorListener {
+class AnalysisErrorListener_21 implements AnalysisErrorListener {
   void onError(AnalysisError event) {
     JUnitTestCase.fail("Unexpected compilation error: ${event.message} (${event.offset}, ${event.length})");
   }
 }
 /**
  * The class `ComplexParserTest` defines parser tests that test the parsing of more complex
  * code fragments or the interactions between multiple parsing methods. For example, tests to ensure
  * that the precedence of operations is being handled correctly should be defined in this class.
  *
  * Simpler tests should be defined in the class [SimpleParserTest].
@@ skipping 1599 matching lines @@
   }
   void fail_unexpectedToken_invalidPostfixExpression() {
     ParserTestCase.parseExpression("f()++", [ParserErrorCode.UNEXPECTED_TOKEN]);
   }
   void fail_varAndType_local() {
     ParserTestCase.parseStatement("var int x;", [ParserErrorCode.VAR_AND_TYPE]);
   }
   void fail_varAndType_parameter() {
     ParserTestCase.parse5("parseFormalParameterList", "(var int x)", [ParserErrorCode.VAR_AND_TYPE]);
   }
-  void fail_voidVariable_initializer() {
-    ParserTestCase.parseStatement("void x = 0;", [ParserErrorCode.VOID_VARIABLE]);
-  }
-  void fail_voidVariable_noInitializer() {
-    ParserTestCase.parseStatement("void x;", [ParserErrorCode.VOID_VARIABLE]);
-  }
   void test_abstractClassMember_constructor() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "abstract C.c();", [ParserErrorCode.ABSTRACT_CLASS_MEMBER]);
   }
   void test_abstractClassMember_field() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "abstract C f;", [ParserErrorCode.ABSTRACT_CLASS_MEMBER]);
   }
   void test_abstractClassMember_getter() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "abstract get m;", [ParserErrorCode.ABSTRACT_CLASS_MEMBER]);
   }
   void test_abstractClassMember_method() {
@@ skipping 161 matching lines @@
     Expression expression = ParserTestCase.parse5("parsePrimaryExpression", "<int, int>[]", [ParserErrorCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS]);
     EngineTestCase.assertInstanceOf(ListLiteral, expression);
   }
   void test_expectedStringLiteral() {
     StringLiteral expression = ParserTestCase.parse5("parseStringLiteral", "1", [ParserErrorCode.EXPECTED_STRING_LITERAL]);
     JUnitTestCase.assertTrue(expression.isSynthetic);
   }
   void test_expectedToken_commaMissingInArgumentList() {
     ParserTestCase.parse5("parseArgumentList", "(x, y z)", [ParserErrorCode.EXPECTED_TOKEN]);
   }
+  void test_expectedToken_parseStatement_afterVoid() {
+    ParserTestCase.parseStatement("void}", [
+        ParserErrorCode.EXPECTED_TOKEN,
+        ParserErrorCode.MISSING_IDENTIFIER]);
+  }
+  void test_expectedToken_semicolonAfterTypedef() {
+    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    ParserTestCase.parse4("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B", [ParserErrorCode.EXPECTED_TOKEN]);
+  }
   void test_expectedToken_semicolonMissingAfterExpression() {
     ParserTestCase.parseStatement("x", [ParserErrorCode.EXPECTED_TOKEN]);
   }
   void test_expectedToken_whileMissingInDoStatement() {
     ParserTestCase.parseStatement("do {} (x);", [ParserErrorCode.EXPECTED_TOKEN]);
   }
   void test_expectedTwoMapTypeArguments_one() {
     Expression expression = ParserTestCase.parse5("parsePrimaryExpression", "<int>{}", [ParserErrorCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
     EngineTestCase.assertInstanceOf(MapLiteral, expression);
   }
@@ skipping 235 matching lines @@
   }
   void test_missingFunctionParameters_topLevel_void_block() {
     ParserTestCase.parseCompilationUnit("void f { return x;}", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
   void test_missingFunctionParameters_topLevel_void_expression() {
     ParserTestCase.parseCompilationUnit("void f => x;", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
   void test_missingIdentifier_afterOperator() {
     ParserTestCase.parse5("parseMultiplicativeExpression", "1 *", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
+  void test_missingIdentifier_beforeClosingCurly() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "int}", [
+        ParserErrorCode.MISSING_IDENTIFIER,
+        ParserErrorCode.EXPECTED_TOKEN]);
+  }
   void test_missingIdentifier_functionDeclaration_returnTypeWithoutName() {
     ParserTestCase.parse5("parseFunctionDeclarationStatement", "A<T> () {}", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
   void test_missingIdentifier_inSymbol_afterPeriod() {
     ParserTestCase.parse5("parseSymbolLiteral", "#a.", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
   void test_missingIdentifier_inSymbol_first() {
     ParserTestCase.parse5("parseSymbolLiteral", "#", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
   void test_missingIdentifier_number() {
     SimpleIdentifier expression = ParserTestCase.parse5("parseSimpleIdentifier", "1", [ParserErrorCode.MISSING_IDENTIFIER]);
     JUnitTestCase.assertTrue(expression.isSynthetic);
   }
   void test_missingKeywordOperator() {
     ParserTestCase.parse4("parseOperator", <Object> [emptyCommentAndMetadata(), null, null], "+(x) {}", [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
   }
+  void test_missingKeywordOperator_parseClassMember() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "+() {}", [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
+  }
+  void test_missingKeywordOperator_parseClassMember_afterTypeName() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "int +() {}", [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
+  }
+  void test_missingKeywordOperator_parseClassMember_afterVoid() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "void +() {}", [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
+  }
   void test_missingNameInLibraryDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("library;", [ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE]);
     JUnitTestCase.assertNotNull(unit);
   }
   void test_missingNameInPartOfDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("part of;", [ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE]);
     JUnitTestCase.assertNotNull(unit);
   }
+  void test_missingStatement() {
+    ParserTestCase.parseStatement("is", [ParserErrorCode.MISSING_STATEMENT]);
+  }
+  void test_missingStatement_afterVoid() {
+    ParserTestCase.parseStatement("void;", [ParserErrorCode.MISSING_STATEMENT]);
+  }
   void test_missingTerminatorForParameterGroup_named() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, {b: 0)", [ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
   void test_missingTerminatorForParameterGroup_optional() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, [b = 0)", [ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
   void test_missingTypedefParameters_nonVoid() {
     ParserTestCase.parseCompilationUnit("typedef int F;", [ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
   }
   void test_missingTypedefParameters_typeParameters() {
     ParserTestCase.parseCompilationUnit("typedef F<E>;", [ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
   }
   void test_missingTypedefParameters_void() {
     ParserTestCase.parseCompilationUnit("typedef void F;", [ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
   }
   void test_missingVariableInForEach() {
     ParserTestCase.parse5("parseForStatement", "for (a < b in foo) {}", [ParserErrorCode.MISSING_VARIABLE_IN_FOR_EACH]);
   }
   void test_mixedParameterGroups_namedPositional() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, {b}, [c])", [ParserErrorCode.MIXED_PARAMETER_GROUPS]);
   }
   void test_mixedParameterGroups_positionalNamed() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, [b], {c})", [ParserErrorCode.MIXED_PARAMETER_GROUPS]);
   }
+  void test_multipleExtendsClauses() {
+    ParserTestCase.parseCompilationUnit("class A extends B extends C {}", [ParserErrorCode.MULTIPLE_EXTENDS_CLAUSES]);
+  }
+  void test_multipleImplementsClauses() {
+    ParserTestCase.parseCompilationUnit("class A implements B implements C {}", [ParserErrorCode.MULTIPLE_IMPLEMENTS_CLAUSES]);
+  }
   void test_multipleLibraryDirectives() {
     ParserTestCase.parseCompilationUnit("library l; library m;", [ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES]);
   }
   void test_multipleNamedParameterGroups() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, {b}, {c})", [ParserErrorCode.MULTIPLE_NAMED_PARAMETER_GROUPS]);
   }
   void test_multiplePartOfDirectives() {
     ParserTestCase.parseCompilationUnit("part of l; part of m;", [ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES]);
   }
   void test_multiplePositionalParameterGroups() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, [b], [c])", [ParserErrorCode.MULTIPLE_POSITIONAL_PARAMETER_GROUPS]);
   }
   void test_multipleVariablesInForEach() {
     ParserTestCase.parse5("parseForStatement", "for (int a, b in foo) {}", [ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH]);
   }
+  void test_multipleWithClauses() {
+    ParserTestCase.parseCompilationUnit("class A extends B with C with D {}", [ParserErrorCode.MULTIPLE_WITH_CLAUSES]);
+  }
   void test_namedParameterOutsideGroup() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, b : 0)", [ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP]);
   }
   void test_nonConstructorFactory_field() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "factory int x;", [ParserErrorCode.NON_CONSTRUCTOR_FACTORY]);
   }
   void test_nonConstructorFactory_method() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "factory int m() {}", [ParserErrorCode.NON_CONSTRUCTOR_FACTORY]);
   }
   void test_nonIdentifierLibraryName_library() {
@@ skipping 12 matching lines @@
   }
   void test_nonUserDefinableOperator() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "operator +=(int x) => x + 1;", [ParserErrorCode.NON_USER_DEFINABLE_OPERATOR]);
   }
   void test_optionalAfterNormalParameters_named() {
     ParserTestCase.parseCompilationUnit("f({a}, b) {}", [ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS]);
   }
   void test_optionalAfterNormalParameters_positional() {
     ParserTestCase.parseCompilationUnit("f([a], b) {}", [ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS]);
   }
+  void test_parseCascadeSection_missingIdentifier() {
+    MethodInvocation methodInvocation = ParserTestCase.parse5("parseCascadeSection", "..()", [ParserErrorCode.MISSING_IDENTIFIER]);
+    JUnitTestCase.assertNull(methodInvocation.target);
+    JUnitTestCase.assertEquals("", methodInvocation.methodName.name);
+    EngineTestCase.assertSize(0, methodInvocation.argumentList.arguments);
+  }
   void test_positionalAfterNamedArgument() {
     ParserTestCase.parse5("parseArgumentList", "(x: 1, 2)", [ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT]);
   }
   void test_positionalParameterOutsideGroup() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, b = 0)", [ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP]);
   }
   void test_redirectionInNonFactoryConstructor() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "C() = D;", [ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR]);
   }
   void test_staticAfterConst() {
@@ skipping 85 matching lines @@
   }
   void test_varClass() {
     ParserTestCase.parseCompilationUnit("var class C {}", [ParserErrorCode.VAR_CLASS]);
   }
   void test_varReturnType() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "var m() {}", [ParserErrorCode.VAR_RETURN_TYPE]);
   }
   void test_varTypedef() {
     ParserTestCase.parseCompilationUnit("var typedef F();", [ParserErrorCode.VAR_TYPEDEF]);
   }
-  void test_voidField_initializer() {
-    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "void x = 0;", [ParserErrorCode.VOID_VARIABLE]);
-  }
-  void test_voidField_noInitializer() {
-    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "void x;", [ParserErrorCode.VOID_VARIABLE]);
-  }
   void test_voidParameter() {
     ParserTestCase.parse5("parseNormalFormalParameter", "void a)", [ParserErrorCode.VOID_PARAMETER]);
   }
+  void test_voidVariable_parseClassMember_initializer() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "void x = 0;", [ParserErrorCode.VOID_VARIABLE]);
+  }
+  void test_voidVariable_parseClassMember_noInitializer() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "void x;", [ParserErrorCode.VOID_VARIABLE]);
+  }
+  void test_voidVariable_parseCompilationUnit_initializer() {
+    ParserTestCase.parseCompilationUnit("void x = 0;", [ParserErrorCode.VOID_VARIABLE]);
+  }
+  void test_voidVariable_parseCompilationUnit_noInitializer() {
+    ParserTestCase.parseCompilationUnit("void x;", [ParserErrorCode.VOID_VARIABLE]);
+  }
+  void test_voidVariable_parseCompilationUnitMember_initializer() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void a = 0;", [ParserErrorCode.VOID_VARIABLE]);
+  }
+  void test_voidVariable_parseCompilationUnitMember_noInitializer() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void a;", [ParserErrorCode.VOID_VARIABLE]);
+  }
+  void test_voidVariable_statement_initializer() {
+    ParserTestCase.parseStatement("void x = 0;", [
+        ParserErrorCode.VOID_VARIABLE,
+        ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE]);
+  }
+  void test_voidVariable_statement_noInitializer() {
+    ParserTestCase.parseStatement("void x;", [
+        ParserErrorCode.VOID_VARIABLE,
+        ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE]);
+  }
   void test_withBeforeExtends() {
     ParserTestCase.parseCompilationUnit("class A with B extends C {}", [ParserErrorCode.WITH_BEFORE_EXTENDS]);
   }
   void test_withWithoutExtends() {
     ParserTestCase.parse4("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A with B, C {}", [ParserErrorCode.WITH_WITHOUT_EXTENDS]);
   }
   void test_wrongSeparatorForNamedParameter() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, {b = 0})", [ParserErrorCode.WRONG_SEPARATOR_FOR_NAMED_PARAMETER]);
   }
   void test_wrongSeparatorForPositionalParameter() {
@@ skipping 236 matching lines @@
         runJUnitTest(__test, __test.test_expectedOneListTypeArguments_two);
       });
       _ut.test('test_expectedStringLiteral', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedStringLiteral);
       });
       _ut.test('test_expectedToken_commaMissingInArgumentList', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_commaMissingInArgumentList);
       });
+      _ut.test('test_expectedToken_parseStatement_afterVoid', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedToken_parseStatement_afterVoid);
+      });
+      _ut.test('test_expectedToken_semicolonAfterTypedef', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedToken_semicolonAfterTypedef);
+      });
       _ut.test('test_expectedToken_semicolonMissingAfterExpression', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_semicolonMissingAfterExpression);
       });
       _ut.test('test_expectedToken_whileMissingInDoStatement', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_whileMissingInDoStatement);
       });
       _ut.test('test_expectedTwoMapTypeArguments_one', () {
         final __test = new ErrorParserTest();
@@ skipping 308 matching lines @@
         runJUnitTest(__test, __test.test_missingFunctionParameters_topLevel_void_block);
       });
       _ut.test('test_missingFunctionParameters_topLevel_void_expression', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingFunctionParameters_topLevel_void_expression);
       });
       _ut.test('test_missingIdentifier_afterOperator', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_afterOperator);
       });
+      _ut.test('test_missingIdentifier_beforeClosingCurly', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingIdentifier_beforeClosingCurly);
+      });
       _ut.test('test_missingIdentifier_functionDeclaration_returnTypeWithoutName', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_functionDeclaration_returnTypeWithoutName);
       });
       _ut.test('test_missingIdentifier_inSymbol_afterPeriod', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_inSymbol_afterPeriod);
       });
       _ut.test('test_missingIdentifier_inSymbol_first', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_inSymbol_first);
       });
       _ut.test('test_missingIdentifier_number', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_number);
       });
       _ut.test('test_missingKeywordOperator', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingKeywordOperator);
       });
+      _ut.test('test_missingKeywordOperator_parseClassMember', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingKeywordOperator_parseClassMember);
+      });
+      _ut.test('test_missingKeywordOperator_parseClassMember_afterTypeName', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingKeywordOperator_parseClassMember_afterTypeName);
+      });
+      _ut.test('test_missingKeywordOperator_parseClassMember_afterVoid', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingKeywordOperator_parseClassMember_afterVoid);
+      });
       _ut.test('test_missingNameInLibraryDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingNameInLibraryDirective);
       });
       _ut.test('test_missingNameInPartOfDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingNameInPartOfDirective);
       });
+      _ut.test('test_missingStatement', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingStatement);
+      });
+      _ut.test('test_missingStatement_afterVoid', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingStatement_afterVoid);
+      });
       _ut.test('test_missingTerminatorForParameterGroup_named', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingTerminatorForParameterGroup_named);
       });
       _ut.test('test_missingTerminatorForParameterGroup_optional', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingTerminatorForParameterGroup_optional);
       });
       _ut.test('test_missingTypedefParameters_nonVoid', () {
         final __test = new ErrorParserTest();
@@ skipping 12 matching lines @@
         runJUnitTest(__test, __test.test_missingVariableInForEach);
       });
       _ut.test('test_mixedParameterGroups_namedPositional', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_mixedParameterGroups_namedPositional);
       });
       _ut.test('test_mixedParameterGroups_positionalNamed', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_mixedParameterGroups_positionalNamed);
       });
+      _ut.test('test_multipleExtendsClauses', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_multipleExtendsClauses);
+      });
+      _ut.test('test_multipleImplementsClauses', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_multipleImplementsClauses);
+      });
       _ut.test('test_multipleLibraryDirectives', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_multipleLibraryDirectives);
       });
       _ut.test('test_multipleNamedParameterGroups', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_multipleNamedParameterGroups);
       });
       _ut.test('test_multiplePartOfDirectives', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_multiplePartOfDirectives);
       });
       _ut.test('test_multiplePositionalParameterGroups', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_multiplePositionalParameterGroups);
       });
       _ut.test('test_multipleVariablesInForEach', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_multipleVariablesInForEach);
       });
+      _ut.test('test_multipleWithClauses', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_multipleWithClauses);
+      });
       _ut.test('test_namedParameterOutsideGroup', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_namedParameterOutsideGroup);
       });
       _ut.test('test_nonConstructorFactory_field', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_nonConstructorFactory_field);
       });
       _ut.test('test_nonConstructorFactory_method', () {
         final __test = new ErrorParserTest();
@@ skipping 20 matching lines @@
         runJUnitTest(__test, __test.test_nonUserDefinableOperator);
       });
       _ut.test('test_optionalAfterNormalParameters_named', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_optionalAfterNormalParameters_named);
       });
       _ut.test('test_optionalAfterNormalParameters_positional', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_optionalAfterNormalParameters_positional);
       });
+      _ut.test('test_parseCascadeSection_missingIdentifier', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_parseCascadeSection_missingIdentifier);
+      });
       _ut.test('test_positionalAfterNamedArgument', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_positionalAfterNamedArgument);
       });
       _ut.test('test_positionalParameterOutsideGroup', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_positionalParameterOutsideGroup);
       });
       _ut.test('test_redirectionInNonFactoryConstructor', () {
         final __test = new ErrorParserTest();
@@ skipping 112 matching lines @@
         runJUnitTest(__test, __test.test_varClass);
       });
       _ut.test('test_varReturnType', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_varReturnType);
       });
       _ut.test('test_varTypedef', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_varTypedef);
       });
-      _ut.test('test_voidField_initializer', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_voidField_initializer);
-      });
-      _ut.test('test_voidField_noInitializer', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_voidField_noInitializer);
-      });
       _ut.test('test_voidParameter', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_voidParameter);
       });
+      _ut.test('test_voidVariable_parseClassMember_initializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_parseClassMember_initializer);
+      });
+      _ut.test('test_voidVariable_parseClassMember_noInitializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_parseClassMember_noInitializer);
+      });
+      _ut.test('test_voidVariable_parseCompilationUnitMember_initializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_parseCompilationUnitMember_initializer);
+      });
+      _ut.test('test_voidVariable_parseCompilationUnitMember_noInitializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_parseCompilationUnitMember_noInitializer);
+      });
+      _ut.test('test_voidVariable_parseCompilationUnit_initializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_parseCompilationUnit_initializer);
+      });
+      _ut.test('test_voidVariable_parseCompilationUnit_noInitializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_parseCompilationUnit_noInitializer);
+      });
+      _ut.test('test_voidVariable_statement_initializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_statement_initializer);
+      });
+      _ut.test('test_voidVariable_statement_noInitializer', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_voidVariable_statement_noInitializer);
+      });
       _ut.test('test_withBeforeExtends', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_withBeforeExtends);
       });
       _ut.test('test_withWithoutExtends', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_withWithoutExtends);
       });
       _ut.test('test_wrongSeparatorForNamedParameter', () {
         final __test = new ErrorParserTest();
@@ skipping 192 matching lines @@
   'validateModifiersForTopLevelFunction_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelFunction(arg0)),
   'validateModifiersForTopLevelVariable_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelVariable(arg0)),
   'validateModifiersForTypedef_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTypedef(arg0)),};
 
 
 Object invokeParserMethodImpl(Parser parser, String methodName, List<Object> objects, Token tokenStream) {
   parser.currentToken = tokenStream;
   MethodTrampoline method = _methodTable_Parser['${methodName}_${objects.length}'];
   return method.invoke(parser, objects);
 }