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 3189 matching lines @@
    * An empty array of objects used as arguments to zero-argument methods.
    */
   static List<Object> _EMPTY_ARGUMENTS = new List<Object>(0);
 
   /**
    * A flag indicating whether parser is to parse function bodies.
    */
   static bool parseFunctionBodies = true;
 
   /**
+   * Create a parser.
+   *
+   * @param listener the listener to be passed to the parser
+   * @return the parser that was created
+   */
+  static Parser createParser(GatheringErrorListener listener) {
+    Parser parser = new Parser(null, listener);
+    parser.parseAsync = true;
+    parser.parseDeferredLibraries = true;
+    parser.parseEnum = true;
+    return parser;
+  }
+
+  /**
    * 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
@@ skipping 71 matching lines @@
    * @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`
    */
   static CompilationUnit parseCompilationUnit(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
-    Parser parser = new Parser(null, listener);
-    parser.parseAsync = true;
-    parser.parseDeferredLibraries = true;
-    parser.parseEnum = true;
+    Parser parser = createParser(listener);
     CompilationUnit unit = parser.parseCompilationUnit(token);
     JUnitTestCase.assertNotNull(unit);
     listener.assertErrorsWithCodes(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`
    */
   static Expression parseExpression(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
-    Parser parser = new Parser(null, listener);
+    Parser parser = createParser(listener);
     Expression expression = parser.parseExpression(token);
     JUnitTestCase.assertNotNull(expression);
     listener.assertErrorsWithCodes(errorCodes);
     return 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`
    */
   static Statement parseStatement(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
-    Parser parser = new Parser(null, listener);
+    Parser parser = createParser(listener);
     Statement statement = parser.parseStatement(token);
     JUnitTestCase.assertNotNull(statement);
     listener.assertErrorsWithCodes(errorCodes);
     return 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`
    */
   static List<Statement> parseStatements(String source, int expectedCount, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
-    Parser parser = new Parser(null, listener);
+    Parser parser = createParser(listener);
     List<Statement> statements = parser.parseStatements(token);
     EngineTestCase.assertSizeOfList(expectedCount, statements);
     listener.assertErrorsWithCodes(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.
    *
@@ skipping 12 matching lines @@
   static Object invokeParserMethod(String methodName, List<Object> objects, String source, GatheringErrorListener listener) {
     //
     // Scan the source.
     //
     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 parser = createParser(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);
     }
@@ skipping 2374 matching lines @@
     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);
   }
 
+  void test_parseAwaitExpression_asStatement_inAsync() {
+    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], EngineTestCase.createSource(["m() async { await x; }"]));
+    FunctionBody body = method.body;
+    EngineTestCase.assertInstanceOf((obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    EngineTestCase.assertInstanceOf((obj) => obj is ExpressionStatement, ExpressionStatement, statement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    EngineTestCase.assertInstanceOf((obj) => obj is AwaitExpression, AwaitExpression, expression);
+    JUnitTestCase.assertNotNull((expression as AwaitExpression).awaitKeyword);
+    JUnitTestCase.assertNotNull((expression as AwaitExpression).expression);
+  }
+
+  void test_parseAwaitExpression_asStatement_inSync() {
+    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], EngineTestCase.createSource(["m() { await x; }"]));
+    FunctionBody body = method.body;
+    EngineTestCase.assertInstanceOf((obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    EngineTestCase.assertInstanceOf((obj) => obj is VariableDeclarationStatement, VariableDeclarationStatement, statement);
+  }
+
   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 4663 matching lines @@
         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_parseAwaitExpression_asStatement_inAsync', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseAwaitExpression_asStatement_inAsync);
+      });
+      _ut.test('test_parseAwaitExpression_asStatement_inSync', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseAwaitExpression_asStatement_inSync);
+      });
       _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 1893 matching lines @@
 
 main() {
   ComplexParserTest.dartSuite();
   ErrorParserTest.dartSuite();
   IncrementalParserTest.dartSuite();
   NonErrorParserTest.dartSuite();
   RecoveryParserTest.dartSuite();
   ResolutionCopierTest.dartSuite();
   SimpleParserTest.dartSuite();
 }