New analyzer snapshot.

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.
 
 // 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 'package:analyzer/src/generated/java_core.dart';
@@ skipping 895 matching lines @@
   }
 
   void test_expectedExecutable_topLevel_afterVoid() {
     ParserTestCase.parse3("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void 2 void", [ParserErrorCode.EXPECTED_EXECUTABLE]);
   }
 
   void test_expectedExecutable_topLevel_beforeType() {
     ParserTestCase.parse3("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "4 score", [ParserErrorCode.EXPECTED_EXECUTABLE]);
   }
 
+  void test_expectedExecutable_topLevel_eof() {
+    ParserTestCase.parse2("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "x", [new AnalysisError.con2(null, 0, 1, ParserErrorCode.EXPECTED_EXECUTABLE, [])]);
+  }
+
   void test_expectedInterpolationIdentifier() {
     ParserTestCase.parse4("parseStringLiteral", "'\$x\$'", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   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.
     ParserTestCase.parse2("parseStringLiteral", <Object> [], "'\$\$foo'", [new AnalysisError.con2(null, 2, 1, ParserErrorCode.MISSING_IDENTIFIER, [])]);
   }
@@ skipping 208 matching lines @@
   }
 
   void test_importDirectiveAfterPartDirective() {
     ParserTestCase.parseCompilationUnit("part 'a.dart'; import 'b.dart';", [ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE]);
   }
 
   void test_initializedVariableInForEach() {
     ParserTestCase.parse4("parseForStatement", "for (int a = 0 in foo) {}", [ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH]);
   }
 
+  void test_invalidAwaitInFor() {
+    ParserTestCase.parse4("parseForStatement", "await for (; ;) {}", [ParserErrorCode.INVALID_AWAIT_IN_FOR]);
+  }
+
   void test_invalidCodePoint() {
     ParserTestCase.parse4("parseStringLiteral", "'\\uD900'", [ParserErrorCode.INVALID_CODE_POINT]);
   }
 
   void test_invalidHexEscape_invalidDigit() {
     ParserTestCase.parse4("parseStringLiteral", "'\\x0 a'", [ParserErrorCode.INVALID_HEX_ESCAPE]);
   }
 
   void test_invalidHexEscape_tooFewDigits() {
     ParserTestCase.parse4("parseStringLiteral", "'\\x0'", [ParserErrorCode.INVALID_HEX_ESCAPE]);
   }
 
   void test_invalidInterpolationIdentifier_startWithDigit() {
     ParserTestCase.parse4("parseStringLiteral", "'\$1'", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_invalidOperator() {
     ParserTestCase.parse3("parseClassMember", <Object> ["C"], "void operator ===(x) {}", [ParserErrorCode.INVALID_OPERATOR]);
   }
 
   void test_invalidOperatorForSuper() {
     ParserTestCase.parse4("parseUnaryExpression", "++super", [ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
   }
 
+  void test_invalidStarAfterAsync() {
+    ParserTestCase.parse3("parseFunctionBody", <Object> [false, null, false], "async* => 0;", [ParserErrorCode.INVALID_STAR_AFTER_ASYNC]);
+  }
+
+  void test_invalidSync() {
+    ParserTestCase.parse3("parseFunctionBody", <Object> [false, null, false], "sync* => 0;", [ParserErrorCode.INVALID_SYNC]);
+  }
+
   void test_invalidUnicodeEscape_incomplete_noDigits() {
     ParserTestCase.parse4("parseStringLiteral", "'\\u{'", [ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
 
   void test_invalidUnicodeEscape_incomplete_someDigits() {
     ParserTestCase.parse4("parseStringLiteral", "'\\u{0A'", [ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
 
   void test_invalidUnicodeEscape_invalidDigit() {
     ParserTestCase.parse4("parseStringLiteral", "'\\u0 a'", [ParserErrorCode.INVALID_UNICODE_ESCAPE]);
@@ skipping 170 matching lines @@
 
   void test_missingNameInPartOfDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("part of;", [ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE]);
     JUnitTestCase.assertNotNull(unit);
   }
 
   void test_missingPrefixInDeferredImport() {
     ParserTestCase.parseCompilationUnit("import 'foo.dart' deferred;", [ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT]);
   }
 
+  void test_missingStartAfterSync() {
+    ParserTestCase.parse3("parseFunctionBody", <Object> [false, null, false], "sync {}", [ParserErrorCode.MISSING_STAR_AFTER_SYNC]);
+  }
+
   void test_missingStatement() {
     ParserTestCase.parseStatement("is", [ParserErrorCode.MISSING_STATEMENT]);
   }
 
   void test_missingStatement_afterVoid() {
     ParserTestCase.parseStatement("void;", [ParserErrorCode.MISSING_STATEMENT]);
   }
 
   void test_missingTerminatorForParameterGroup_named() {
     ParserTestCase.parse4("parseFormalParameterList", "(a, {b: 0)", [ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP]);
@@ skipping 565 matching lines @@
         runJUnitTest(__test, __test.test_expectedExecutable_topLevel_afterType);
       });
       _ut.test('test_expectedExecutable_topLevel_afterVoid', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedExecutable_topLevel_afterVoid);
       });
       _ut.test('test_expectedExecutable_topLevel_beforeType', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedExecutable_topLevel_beforeType);
       });
+      _ut.test('test_expectedExecutable_topLevel_eof', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedExecutable_topLevel_eof);
+      });
       _ut.test('test_expectedInterpolationIdentifier', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedInterpolationIdentifier);
       });
       _ut.test('test_expectedInterpolationIdentifier_emptyString', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedInterpolationIdentifier_emptyString);
       });
       _ut.test('test_expectedStringLiteral', () {
         final __test = new ErrorParserTest();
@@ skipping 188 matching lines @@
         runJUnitTest(__test, __test.test_implementsBeforeWith);
       });
       _ut.test('test_importDirectiveAfterPartDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_importDirectiveAfterPartDirective);
       });
       _ut.test('test_initializedVariableInForEach', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_initializedVariableInForEach);
       });
+      _ut.test('test_invalidAwaitInFor', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_invalidAwaitInFor);
+      });
       _ut.test('test_invalidCodePoint', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidCodePoint);
       });
       _ut.test('test_invalidHexEscape_invalidDigit', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidHexEscape_invalidDigit);
       });
       _ut.test('test_invalidHexEscape_tooFewDigits', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidHexEscape_tooFewDigits);
       });
       _ut.test('test_invalidInterpolationIdentifier_startWithDigit', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidInterpolationIdentifier_startWithDigit);
       });
       _ut.test('test_invalidOperator', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidOperator);
       });
       _ut.test('test_invalidOperatorForSuper', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidOperatorForSuper);
       });
+      _ut.test('test_invalidStarAfterAsync', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_invalidStarAfterAsync);
+      });
+      _ut.test('test_invalidSync', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_invalidSync);
+      });
       _ut.test('test_invalidUnicodeEscape_incomplete_noDigits', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidUnicodeEscape_incomplete_noDigits);
       });
       _ut.test('test_invalidUnicodeEscape_incomplete_someDigits', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidUnicodeEscape_incomplete_someDigits);
       });
       _ut.test('test_invalidUnicodeEscape_invalidDigit', () {
         final __test = new ErrorParserTest();
@@ skipping 160 matching lines @@
         runJUnitTest(__test, __test.test_missingNameInLibraryDirective);
       });
       _ut.test('test_missingNameInPartOfDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingNameInPartOfDirective);
       });
       _ut.test('test_missingPrefixInDeferredImport', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingPrefixInDeferredImport);
       });
+      _ut.test('test_missingStartAfterSync', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingStartAfterSync);
+      });
       _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();
@@ skipping 924 matching lines @@
     //
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     parser.parseFunctionBodies = parseFunctionBodies;
     parser.parseDeferredLibraries = true;
+    parser.parseAsync = true;
     Object result = invokeParserMethodImpl(parser, methodName, objects, tokenStream);
     //
     // Partially test the results.
     //
     if (!listener.hasErrors) {
       JUnitTestCase.assertNotNull(result);
     }
     return result;
   }
 
@@ skipping 2239 matching lines @@
     JUnitTestCase.assertNotNull(selector.leftBracket);
     JUnitTestCase.assertNotNull(selector.index);
     JUnitTestCase.assertNotNull(selector.rightBracket);
   }
 
   void test_parseAssignableSelector_none() {
     SimpleIdentifier selector = ParserTestCase.parse("parseAssignableSelector", <Object> [new SimpleIdentifier(null), true], ";");
     JUnitTestCase.assertNotNull(selector);
   }
 
+  void test_parseAwaitExpression() {
+    AwaitExpression expression = ParserTestCase.parse4("parseAwaitExpression", "await x;", []);
+    JUnitTestCase.assertNotNull(expression.awaitKeyword);
+    JUnitTestCase.assertNotNull(expression.expression);
+    JUnitTestCase.assertNotNull(expression.semicolon);
+  }
+
   void test_parseBitwiseAndExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseAndExpression", "x & y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.AMPERSAND, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseBitwiseAndExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseAndExpression", "super & y", []);
@@ skipping 1853 matching lines @@
 
   void test_parseFormalParameterList_positional_single() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "([A a = null])", []);
     JUnitTestCase.assertNotNull(parameterList.leftParenthesis);
     JUnitTestCase.assertNotNull(parameterList.leftDelimiter);
     EngineTestCase.assertSizeOfList(1, parameterList.parameters);
     JUnitTestCase.assertNotNull(parameterList.rightDelimiter);
     JUnitTestCase.assertNotNull(parameterList.rightParenthesis);
   }
 
+  void test_parseForStatement_each_await() {
+    ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "await for (element in list) {}", []);
+    JUnitTestCase.assertNotNull(statement.awaitKeyword);
+    JUnitTestCase.assertNotNull(statement.forKeyword);
+    JUnitTestCase.assertNotNull(statement.leftParenthesis);
+    JUnitTestCase.assertNull(statement.loopVariable);
+    JUnitTestCase.assertNotNull(statement.identifier);
+    JUnitTestCase.assertNotNull(statement.inKeyword);
+    JUnitTestCase.assertNotNull(statement.iterator);
+    JUnitTestCase.assertNotNull(statement.rightParenthesis);
+    JUnitTestCase.assertNotNull(statement.body);
+  }
+
   void test_parseForStatement_each_identifier() {
     ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "for (element in list) {}", []);
+    JUnitTestCase.assertNull(statement.awaitKeyword);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNull(statement.loopVariable);
     JUnitTestCase.assertNotNull(statement.identifier);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
 
   void test_parseForStatement_each_noType_metadata() {
     ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "for (@A var element in list) {}", []);
+    JUnitTestCase.assertNull(statement.awaitKeyword);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNotNull(statement.loopVariable);
     EngineTestCase.assertSizeOfList(1, statement.loopVariable.metadata);
     JUnitTestCase.assertNull(statement.identifier);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
 
   void test_parseForStatement_each_type() {
     ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "for (A element in list) {}", []);
+    JUnitTestCase.assertNull(statement.awaitKeyword);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNotNull(statement.loopVariable);
     JUnitTestCase.assertNull(statement.identifier);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
 
   void test_parseForStatement_each_var() {
     ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "for (var element in list) {}", []);
+    JUnitTestCase.assertNull(statement.awaitKeyword);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNotNull(statement.loopVariable);
     JUnitTestCase.assertNull(statement.identifier);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
 
@@ skipping 146 matching lines @@
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSizeOfList(1, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
 
   void test_parseFunctionBody_block() {
     BlockFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "{}");
+    JUnitTestCase.assertNull(functionBody.keyword);
+    JUnitTestCase.assertNull(functionBody.star);
     JUnitTestCase.assertNotNull(functionBody.block);
+    JUnitTestCase.assertFalse(functionBody.isAsynchronous);
+    JUnitTestCase.assertFalse(functionBody.isGenerator);
+    JUnitTestCase.assertTrue(functionBody.isSynchronous);
+  }
+
+  void test_parseFunctionBody_block_async() {
+    BlockFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "async {}");
+    JUnitTestCase.assertNotNull(functionBody.keyword);
+    JUnitTestCase.assertEquals(Parser.ASYNC, functionBody.keyword.lexeme);
+    JUnitTestCase.assertNull(functionBody.star);
+    JUnitTestCase.assertNotNull(functionBody.block);
+    JUnitTestCase.assertTrue(functionBody.isAsynchronous);
+    JUnitTestCase.assertFalse(functionBody.isGenerator);
+    JUnitTestCase.assertFalse(functionBody.isSynchronous);
+  }
+
+  void test_parseFunctionBody_block_asyncGenerator() {
+    BlockFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "async* {}");
+    JUnitTestCase.assertNotNull(functionBody.keyword);
+    JUnitTestCase.assertEquals(Parser.ASYNC, functionBody.keyword.lexeme);
+    JUnitTestCase.assertNotNull(functionBody.star);
+    JUnitTestCase.assertNotNull(functionBody.block);
+    JUnitTestCase.assertTrue(functionBody.isAsynchronous);
+    JUnitTestCase.assertTrue(functionBody.isGenerator);
+    JUnitTestCase.assertFalse(functionBody.isSynchronous);
+  }
+
+  void test_parseFunctionBody_block_syncGenerator() {
+    BlockFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "sync* {}");
+    JUnitTestCase.assertNotNull(functionBody.keyword);
+    JUnitTestCase.assertEquals(Parser.SYNC, functionBody.keyword.lexeme);
+    JUnitTestCase.assertNotNull(functionBody.star);
+    JUnitTestCase.assertNotNull(functionBody.block);
+    JUnitTestCase.assertFalse(functionBody.isAsynchronous);
+    JUnitTestCase.assertTrue(functionBody.isGenerator);
+    JUnitTestCase.assertTrue(functionBody.isSynchronous);
   }
 
   void test_parseFunctionBody_empty() {
     EmptyFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [true, null, false], ";");
     JUnitTestCase.assertNotNull(functionBody.semicolon);
   }
 
   void test_parseFunctionBody_expression() {
     ExpressionFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "=> y;");
+    JUnitTestCase.assertNull(functionBody.keyword);
     JUnitTestCase.assertNotNull(functionBody.functionDefinition);
     JUnitTestCase.assertNotNull(functionBody.expression);
     JUnitTestCase.assertNotNull(functionBody.semicolon);
+    JUnitTestCase.assertFalse(functionBody.isAsynchronous);
+    JUnitTestCase.assertFalse(functionBody.isGenerator);
+    JUnitTestCase.assertTrue(functionBody.isSynchronous);
+  }
+
+  void test_parseFunctionBody_expression_async() {
+    ExpressionFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "async => y;");
+    JUnitTestCase.assertNotNull(functionBody.keyword);
+    JUnitTestCase.assertEquals(Parser.ASYNC, functionBody.keyword.lexeme);
+    JUnitTestCase.assertNotNull(functionBody.functionDefinition);
+    JUnitTestCase.assertNotNull(functionBody.expression);
+    JUnitTestCase.assertNotNull(functionBody.semicolon);
+    JUnitTestCase.assertTrue(functionBody.isAsynchronous);
+    JUnitTestCase.assertFalse(functionBody.isGenerator);
+    JUnitTestCase.assertFalse(functionBody.isSynchronous);
   }
 
   void test_parseFunctionBody_nativeFunctionBody() {
     NativeFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "native 'str';");
     JUnitTestCase.assertNotNull(functionBody.nativeToken);
     JUnitTestCase.assertNotNull(functionBody.stringLiteral);
     JUnitTestCase.assertNotNull(functionBody.semicolon);
   }
 
   void test_parseFunctionBody_skip_block() {
@@ skipping 1797 matching lines @@
     JUnitTestCase.assertNotNull(clause.withKeyword);
     EngineTestCase.assertSizeOfList(3, clause.mixinTypes);
   }
 
   void test_parseWithClause_single() {
     WithClause clause = ParserTestCase.parse4("parseWithClause", "with M", []);
     JUnitTestCase.assertNotNull(clause.withKeyword);
     EngineTestCase.assertSizeOfList(1, clause.mixinTypes);
   }
 
+  void test_parseYieldStatement_each() {
+    YieldStatement statement = ParserTestCase.parse4("parseYieldStatement", "yield* x;", []);
+    JUnitTestCase.assertNotNull(statement.yieldKeyword);
+    JUnitTestCase.assertNotNull(statement.star);
+    JUnitTestCase.assertNotNull(statement.expression);
+    JUnitTestCase.assertNotNull(statement.semicolon);
+  }
+
+  void test_parseYieldStatement_normal() {
+    YieldStatement statement = ParserTestCase.parse4("parseYieldStatement", "yield x;", []);
+    JUnitTestCase.assertNotNull(statement.yieldKeyword);
+    JUnitTestCase.assertNull(statement.star);
+    JUnitTestCase.assertNotNull(statement.expression);
+    JUnitTestCase.assertNotNull(statement.semicolon);
+  }
+
   void test_skipPrefixedIdentifier_invalid() {
     Token following = _skip("skipPrefixedIdentifier", "+");
     JUnitTestCase.assertNull(following);
   }
 
   void test_skipPrefixedIdentifier_notPrefixed() {
     Token following = _skip("skipPrefixedIdentifier", "a +");
     JUnitTestCase.assertNotNull(following);
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
@@ skipping 626 matching lines @@
         runJUnitTest(__test, __test.test_parseAssignableSelector_dot);
       });
       _ut.test('test_parseAssignableSelector_index', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseAssignableSelector_index);
       });
       _ut.test('test_parseAssignableSelector_none', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseAssignableSelector_none);
       });
+      _ut.test('test_parseAwaitExpression', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseAwaitExpression);
+      });
       _ut.test('test_parseBitwiseAndExpression_normal', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseBitwiseAndExpression_normal);
       });
       _ut.test('test_parseBitwiseAndExpression_super', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseBitwiseAndExpression_super);
       });
       _ut.test('test_parseBitwiseOrExpression_normal', () {
         final __test = new SimpleParserTest();
@@ skipping 724 matching lines @@
         runJUnitTest(__test, __test.test_parseFinalConstVarOrType_type_prefixedAndParameterized);
       });
       _ut.test('test_parseFinalConstVarOrType_type_simple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFinalConstVarOrType_type_simple);
       });
       _ut.test('test_parseFinalConstVarOrType_var', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFinalConstVarOrType_var);
       });
+      _ut.test('test_parseForStatement_each_await', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseForStatement_each_await);
+      });
       _ut.test('test_parseForStatement_each_identifier', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseForStatement_each_identifier);
       });
       _ut.test('test_parseForStatement_each_noType_metadata', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseForStatement_each_noType_metadata);
       });
       _ut.test('test_parseForStatement_each_type', () {
         final __test = new SimpleParserTest();
@@ skipping 112 matching lines @@
         runJUnitTest(__test, __test.test_parseFormalParameter_var_named);
       });
       _ut.test('test_parseFormalParameter_var_positional', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFormalParameter_var_positional);
       });
       _ut.test('test_parseFunctionBody_block', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionBody_block);
       });
+      _ut.test('test_parseFunctionBody_block_async', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseFunctionBody_block_async);
+      });
+      _ut.test('test_parseFunctionBody_block_asyncGenerator', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseFunctionBody_block_asyncGenerator);
+      });
+      _ut.test('test_parseFunctionBody_block_syncGenerator', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseFunctionBody_block_syncGenerator);
+      });
       _ut.test('test_parseFunctionBody_empty', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionBody_empty);
       });
       _ut.test('test_parseFunctionBody_expression', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionBody_expression);
       });
+      _ut.test('test_parseFunctionBody_expression_async', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseFunctionBody_expression_async);
+      });
       _ut.test('test_parseFunctionBody_nativeFunctionBody', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionBody_nativeFunctionBody);
       });
       _ut.test('test_parseFunctionBody_skip_block', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionBody_skip_block);
       });
       _ut.test('test_parseFunctionBody_skip_block_invalid', () {
         final __test = new SimpleParserTest();
@@ skipping 876 matching lines @@
         runJUnitTest(__test, __test.test_parseWhileStatement);
       });
       _ut.test('test_parseWithClause_multiple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseWithClause_multiple);
       });
       _ut.test('test_parseWithClause_single', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseWithClause_single);
       });
+      _ut.test('test_parseYieldStatement_each', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseYieldStatement_each);
+      });
+      _ut.test('test_parseYieldStatement_normal', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseYieldStatement_normal);
+      });
       _ut.test('test_skipPrefixedIdentifier_invalid', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipPrefixedIdentifier_invalid);
       });
       _ut.test('test_skipPrefixedIdentifier_notPrefixed', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipPrefixedIdentifier_notPrefixed);
       });
       _ut.test('test_skipPrefixedIdentifier_prefixed', () {
         final __test = new SimpleParserTest();
@@ skipping 69 matching lines @@
 
 main() {
   ComplexParserTest.dartSuite();
   ErrorParserTest.dartSuite();
   IncrementalParserTest.dartSuite();
   NonErrorParserTest.dartSuite();
   RecoveryParserTest.dartSuite();
   ResolutionCopierTest.dartSuite();
   SimpleParserTest.dartSuite();
 }