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 3651 matching lines @@
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
   void test_skipTypeName_simple() {
     Token following = skip("skipTypeName", "C +");
     JUnitTestCase.assertNotNull(following);
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
 
   /**
    * 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_19();
+    AnalysisErrorListener listener = new AnalysisErrorListener_20();
     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
    * @throws Exception if the method could not be invoked or throws an exception
    */
   SimpleIdentifier createSyntheticIdentifier() {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("createSyntheticIdentifier", "", listener);
   }
 
   /**
    * 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
    * @throws Exception if the method could not be invoked or throws an exception
    */
   SimpleStringLiteral createSyntheticStringLiteral() {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("createSyntheticStringLiteral", "", listener);
   }
 
   /**
    * 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) {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("isFunctionDeclaration", source, listener) as bool;
   }
 
   /**
    * 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) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "isFunctionExpression", <Object> [tokenStream], tokenStream) as bool;
   }
 
   /**
    * 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) {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("isInitializedVariableDeclaration", source, listener) as bool;
   }
 
   /**
    * 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) {
     GatheringErrorListener listener = new GatheringErrorListener();
     return ParserTestCase.invokeParserMethod2("isSwitchMember", source, listener) as bool;
   }
 
   /**
    * Invoke a "skip" method in [Parser]. The method is assumed to take a token as it's
    * parameter and is given the first token in the scanned source.
+   *
    * @param methodName the name of the method that should be invoked
    * @param source the source to be processed by the method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is `null`
    */
   Token skip(String methodName, String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
@@ skipping 2070 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_19 implements AnalysisErrorListener {
+class AnalysisErrorListener_20 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 427 matching lines @@
       JUnitTestCase.fail(builder.toString());
     }
   }
   Object visitNode(ASTNode node) {
     validate(node);
     return super.visitNode(node);
   }
 
   /**
    * Validate that the given AST node is correctly constructed.
+   *
    * @param node the AST node being validated
    */
   void validate(ASTNode node) {
     ASTNode parent = node.parent;
     if (node is CompilationUnit) {
       if (parent != null) {
         _errors.add("Compilation units should not have a parent");
       }
     } else {
       if (parent == null) {
@@ skipping 30 matching lines @@
    * An empty array of objects used as arguments to zero-argument methods.
    */
   static List<Object> _EMPTY_ARGUMENTS = new List<Object>(0);
 
   /**
    * Invoke a parse method in [Parser]. The method is assumed to have the given number and
    * type of parameters and will be invoked with the given arguments.
    *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
+   *
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param objects the values of the arguments to the method
    * @param source the source to be parsed by the parse method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is `null` or if any errors are produced
    */
   static Object parse(String methodName, List<Object> objects, String source) => parse3(methodName, objects, source, new List<AnalysisError>(0));
 
   /**
    * Invoke a parse method in [Parser]. The method is assumed to have the given number and
    * type of parameters and will be invoked with the given arguments.
    *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
+   *
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param objects the values of the arguments to the method
    * @param source the source to be parsed by the parse method
    * @param errorCodes the error codes of the errors that should be generated
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is `null` or the errors produced while
-   * scanning and parsing the source do not match the expected errors
+   *           scanning and parsing the source do not match the expected errors
    */
   static Object parse3(String methodName, List<Object> objects, String source, List<AnalysisError> errors) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Object result = invokeParserMethod(methodName, objects, source, listener);
     listener.assertErrors(errors);
     return result;
   }
 
   /**
    * Invoke a parse method in [Parser]. The method is assumed to have the given number and
    * type of parameters and will be invoked with the given arguments.
    *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
+   *
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param objects the values of the arguments to the method
    * @param source the source to be parsed by the parse method
    * @param errorCodes the error codes of the errors that should be generated
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is `null` or the errors produced while
-   * scanning and parsing the source do not match the expected errors
+   *           scanning and parsing the source do not match the expected errors
    */
   static Object parse4(String methodName, List<Object> objects, String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Object result = invokeParserMethod(methodName, objects, source, listener);
     listener.assertErrors2(errorCodes);
     return result;
   }
 
   /**
    * Invoke a parse method in [Parser]. The method is assumed to have no arguments.
    *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the parse method is invoked.
+   *
    * @param methodName the name of the parse method that should be invoked to parse the source
    * @param source the source to be parsed by the parse method
    * @param errorCodes the error codes of the errors that should be generated
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is `null` or the errors produced while
-   * scanning and parsing the source do not match the expected errors
+   *           scanning and parsing the source do not match the expected errors
    */
   static Object parse5(String methodName, String source, List<ErrorCode> errorCodes) => parse4(methodName, _EMPTY_ARGUMENTS, source, errorCodes);
 
   /**
    * Parse the given source as a compilation unit.
+   *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the compilation unit that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
-   * not match those that are expected, or if the result would have been `null`
+   *           not match those that are expected, or if the result would have been `null`
    */
   static CompilationUnit parseCompilationUnit(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     CompilationUnit unit = parser.parseCompilationUnit(token);
     JUnitTestCase.assertNotNull(unit);
     listener.assertErrors2(errorCodes);
     return unit;
   }
 
   /**
    * Parse the given source as an expression.
+   *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the expression that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
-   * not match those that are expected, or if the result would have been `null`
+   *           not match those that are expected, or if the result would have been `null`
    */
   static Expression parseExpression(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     Expression expression = parser.parseExpression(token);
     JUnitTestCase.assertNotNull(expression);
     listener.assertErrors2(errorCodes);
     return expression as Expression;
   }
 
   /**
    * Parse the given source as a statement.
+   *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the statement that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
-   * not match those that are expected, or if the result would have been `null`
+   *           not match those that are expected, or if the result would have been `null`
    */
   static Statement parseStatement(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     Statement statement = parser.parseStatement(token);
     JUnitTestCase.assertNotNull(statement);
     listener.assertErrors2(errorCodes);
     return statement as Statement;
   }
 
   /**
    * Parse the given source as a sequence of statements.
+   *
    * @param source the source to be parsed
    * @param expectedCount the number of statements that are expected
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the statements that were parsed
    * @throws Exception if the source could not be parsed, if the number of statements does not match
-   * the expected count, if the compilation errors in the source do not match those that
-   * are expected, or if the result would have been `null`
+   *           the expected count, if the compilation errors in the source do not match those that
+   *           are expected, or if the result would have been `null`
    */
   static List<Statement> parseStatements(String source, int expectedCount, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     List<Statement> statements = parser.parseStatements(token);
     EngineTestCase.assertSize(expectedCount, statements);
     listener.assertErrors2(errorCodes);
     return statements;
   }
 
   /**
    * Invoke a method in [Parser]. The method is assumed to have the given number and type of
    * parameters and will be invoked with the given arguments.
    *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the method is invoked.
+   *
    * @param methodName the name of the method that should be invoked
    * @param objects the values of the arguments to the method
    * @param source the source to be processed by the parse method
    * @param listener the error listener that will be used for both scanning and parsing
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is `null` or the errors produced while
-   * scanning and parsing the source do not match the expected errors
+   *           scanning and parsing the source do not match the expected errors
    */
   static Object invokeParserMethod(String methodName, List<Object> objects, String source, GatheringErrorListener listener) {
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Parser parser = new Parser(null, listener);
     Object result = invokeParserMethodImpl(parser, methodName, objects, tokenStream);
     if (!listener.hasErrors()) {
       JUnitTestCase.assertNotNull(result);
     }
     return result as Object;
   }
 
   /**
    * Invoke a method in [Parser]. The method is assumed to have no arguments.
    *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the method is invoked.
+   *
    * @param methodName the name of the method that should be invoked
    * @param source the source to be processed by the parse method
    * @param listener the error listener that will be used for both scanning and parsing
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is `null` or the errors produced while
-   * scanning and parsing the source do not match the expected errors
+   *           scanning and parsing the source do not match the expected errors
    */
   static Object invokeParserMethod2(String methodName, String source, GatheringErrorListener listener) => invokeParserMethod(methodName, _EMPTY_ARGUMENTS, source, listener);
 
   /**
    * Return a CommentAndMetadata object with the given values that can be used for testing.
+   *
    * @param comment the comment to be wrapped in the object
    * @param annotations the annotations to be wrapped in the object
    * @return a CommentAndMetadata object that can be used for testing
    */
   CommentAndMetadata commentAndMetadata(Comment comment, List<Annotation> annotations) {
     List<Annotation> metadata = new List<Annotation>();
     for (Annotation annotation in annotations) {
       metadata.add(annotation);
     }
     return new CommentAndMetadata(comment, metadata);
   }
 
   /**
    * Return an empty CommentAndMetadata object that can be used for testing.
+   *
    * @return an empty CommentAndMetadata object that can be used for testing
    */
   CommentAndMetadata emptyCommentAndMetadata() => new CommentAndMetadata(null, new List<Annotation>());
   static dartSuite() {
     _ut.group('ParserTestCase', () {
     });
   }
 }
 /**
  * The class `RecoveryParserTest` defines parser tests that test the parsing of invalid code
@@ skipping 1078 matching lines @@
   void test_invalidUnicodeEscape_tooManyDigits_variable() {
     ParserTestCase.parse5("parseStringLiteral", "'\\u{12345678}'", [ParserErrorCode.INVALID_UNICODE_ESCAPE, ParserErrorCode.INVALID_CODE_POINT]);
   }
   void test_libraryDirectiveNotFirst() {
     ParserTestCase.parseCompilationUnit("import 'x.dart'; library l;", [ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST]);
   }
   void test_libraryDirectiveNotFirst_afterPart() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("part 'a.dart';\nlibrary l;", [ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST]);
     JUnitTestCase.assertNotNull(unit);
   }
+  void test_localFunctionDeclarationModifier_abstract() {
+    ParserTestCase.parseStatement("abstract f() {}", [ParserErrorCode.LOCAL_FUNCTION_DECLARATION_MODIFIER]);
+  }
+  void test_localFunctionDeclarationModifier_external() {
+    ParserTestCase.parseStatement("external f() {}", [ParserErrorCode.LOCAL_FUNCTION_DECLARATION_MODIFIER]);
+  }
+  void test_localFunctionDeclarationModifier_factory() {
+    ParserTestCase.parseStatement("factory f() {}", [ParserErrorCode.LOCAL_FUNCTION_DECLARATION_MODIFIER]);
+  }
+  void test_localFunctionDeclarationModifier_static() {
+    ParserTestCase.parseStatement("static f() {}", [ParserErrorCode.LOCAL_FUNCTION_DECLARATION_MODIFIER]);
+  }
   void test_missingAssignableSelector_identifiersAssigned() {
     ParserTestCase.parseExpression("x.y = y;", []);
   }
+  void test_missingAssignableSelector_postfix_minusMinus_literal() {
+    ParserTestCase.parseExpression("0--", [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
+  }
+  void test_missingAssignableSelector_postfix_plusPlus_literal() {
+    ParserTestCase.parseExpression("0++", [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
+  }
+  void test_missingAssignableSelector_prefix_minusMinus_literal() {
+    ParserTestCase.parseExpression("--0", [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
+  }
+  void test_missingAssignableSelector_prefix_plusPlus_literal() {
+    ParserTestCase.parseExpression("++0", [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
+  }
   void test_missingAssignableSelector_primarySelectorPostfix() {
     ParserTestCase.parseExpression("x(y)(z)++", [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
   }
   void test_missingAssignableSelector_selector() {
     ParserTestCase.parseExpression("x(y)(z).a++", []);
   }
   void test_missingAssignableSelector_superPrimaryExpression() {
     SuperExpression expression = ParserTestCase.parse5("parsePrimaryExpression", "super", [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
     JUnitTestCase.assertNotNull(expression.keyword);
   }
@@ skipping 122 matching lines @@
   }
   void test_nonPartOfDirectiveInPart_after() {
     ParserTestCase.parseCompilationUnit("part of l; part 'f.dart';", [ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART]);
   }
   void test_nonPartOfDirectiveInPart_before() {
     ParserTestCase.parseCompilationUnit("part 'f.dart'; part of m;", [ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART]);
   }
   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_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_staticAfterConst() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "final static int f;", [ParserErrorCode.STATIC_AFTER_FINAL]);
   }
   void test_staticAfterFinal() {
@@ skipping 13 matching lines @@
   }
   void test_staticOperator_returnType() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "static int operator +(int x) => x + 1;", [ParserErrorCode.STATIC_OPERATOR]);
   }
   void test_staticSetterWithoutBody() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "static set m(x);", [ParserErrorCode.STATIC_SETTER_WITHOUT_BODY]);
   }
   void test_staticTopLevelDeclaration_class() {
     ParserTestCase.parseCompilationUnit("static class C {}", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
   }
+  void test_staticTopLevelDeclaration_function() {
+    ParserTestCase.parseCompilationUnit("static f() {}", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
+  }
   void test_staticTopLevelDeclaration_typedef() {
     ParserTestCase.parseCompilationUnit("static typedef F();", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
   }
   void test_staticTopLevelDeclaration_variable() {
     ParserTestCase.parseCompilationUnit("static var x;", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
   }
   void test_switchHasCaseAfterDefaultCase() {
     ParserTestCase.parse5("parseSwitchStatement", "switch (a) {default: return 0; case 1: return 1;}", [ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE]);
   }
   void test_switchHasCaseAfterDefaultCase_repeated() {
@@ skipping 489 matching lines @@
         runJUnitTest(__test, __test.test_invalidUnicodeEscape_tooManyDigits_variable);
       });
       _ut.test('test_libraryDirectiveNotFirst', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_libraryDirectiveNotFirst);
       });
       _ut.test('test_libraryDirectiveNotFirst_afterPart', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_libraryDirectiveNotFirst_afterPart);
       });
+      _ut.test('test_localFunctionDeclarationModifier_abstract', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_localFunctionDeclarationModifier_abstract);
+      });
+      _ut.test('test_localFunctionDeclarationModifier_external', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_localFunctionDeclarationModifier_external);
+      });
+      _ut.test('test_localFunctionDeclarationModifier_factory', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_localFunctionDeclarationModifier_factory);
+      });
+      _ut.test('test_localFunctionDeclarationModifier_static', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_localFunctionDeclarationModifier_static);
+      });
       _ut.test('test_missingAssignableSelector_identifiersAssigned', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingAssignableSelector_identifiersAssigned);
       });
+      _ut.test('test_missingAssignableSelector_postfix_minusMinus_literal', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingAssignableSelector_postfix_minusMinus_literal);
+      });
+      _ut.test('test_missingAssignableSelector_postfix_plusPlus_literal', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingAssignableSelector_postfix_plusPlus_literal);
+      });
+      _ut.test('test_missingAssignableSelector_prefix_minusMinus_literal', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingAssignableSelector_prefix_minusMinus_literal);
+      });
+      _ut.test('test_missingAssignableSelector_prefix_plusPlus_literal', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingAssignableSelector_prefix_plusPlus_literal);
+      });
       _ut.test('test_missingAssignableSelector_primarySelectorPostfix', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingAssignableSelector_primarySelectorPostfix);
       });
       _ut.test('test_missingAssignableSelector_selector', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingAssignableSelector_selector);
       });
       _ut.test('test_missingAssignableSelector_superPrimaryExpression', () {
         final __test = new ErrorParserTest();
@@ skipping 160 matching lines @@
         runJUnitTest(__test, __test.test_nonPartOfDirectiveInPart_after);
       });
       _ut.test('test_nonPartOfDirectiveInPart_before', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_nonPartOfDirectiveInPart_before);
       });
       _ut.test('test_nonUserDefinableOperator', () {
         final __test = new ErrorParserTest();
         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_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_staticAfterConst', () {
         final __test = new ErrorParserTest();
@@ skipping 24 matching lines @@
         runJUnitTest(__test, __test.test_staticOperator_returnType);
       });
       _ut.test('test_staticSetterWithoutBody', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_staticSetterWithoutBody);
       });
       _ut.test('test_staticTopLevelDeclaration_class', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_staticTopLevelDeclaration_class);
       });
+      _ut.test('test_staticTopLevelDeclaration_function', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_staticTopLevelDeclaration_function);
+      });
       _ut.test('test_staticTopLevelDeclaration_typedef', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_staticTopLevelDeclaration_typedef);
       });
       _ut.test('test_staticTopLevelDeclaration_variable', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_staticTopLevelDeclaration_variable);
       });
       _ut.test('test_switchHasCaseAfterDefaultCase', () {
         final __test = new ErrorParserTest();
@@ skipping 259 matching lines @@
   'skipStringInterpolation_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipStringInterpolation(arg0)),
   'skipStringLiteral_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipStringLiteral(arg0)),
   'skipTypeArgumentList_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeArgumentList(arg0)),
   'skipTypeName_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeName(arg0)),
   'skipTypeParameterList_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeParameterList(arg0)),
   'translateCharacter_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.translateCharacter(arg0, arg1, arg2)),
   'validateFormalParameterList_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateFormalParameterList(arg0)),
   'validateModifiersForClass_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForClass(arg0)),
   'validateModifiersForConstructor_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForConstructor(arg0)),
   'validateModifiersForField_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForField(arg0)),
+  'validateModifiersForFunctionDeclarationStatement_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForFunctionDeclarationStatement(arg0)),
   'validateModifiersForGetterOrSetterOrMethod_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForGetterOrSetterOrMethod(arg0)),
   'validateModifiersForOperator_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForOperator(arg0)),
   'validateModifiersForTopLevelDeclaration_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelDeclaration(arg0)),
   '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);
 }