Fix for issue 22052

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.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/incremental_scanner.dart';
@@ skipping 5147 matching lines @@
 
 /**
  * The class `SimpleParserTest` defines parser tests that test individual parsing method. The
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
  *
  * More complex tests should be defined in the class [ComplexParserTest].
  */
 @reflectiveTest
 class SimpleParserTest extends ParserTestCase {
+  void fail_parseAwaitExpression_inSync() {
+    // This test requires better error recovery than we currently have. In
+    // particular, we need to be able to distinguish between an await expression
+    // in the wrong context, and the use of 'await' as an identifier.
+    MethodDeclaration method = ParserTestCase.parse(
+        "parseClassMember",
+        <Object>["C"],
+        "m() { return await x + await y; }");
+    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 ReturnStatement,
+        ReturnStatement,
+        statement);
+    Expression expression = (statement as ReturnStatement).expression;
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is BinaryExpression,
+        BinaryExpression,
+        expression);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AwaitExpression,
+        AwaitExpression,
+        (expression as BinaryExpression).leftOperand);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AwaitExpression,
+        AwaitExpression,
+        (expression as BinaryExpression).rightOperand);
+  }
+
   void fail_parseCommentReference_this() {
     // This fails because we are returning null from the method and asserting
     // that the return value is not null.
     CommentReference reference =
         ParserTestCase.parse("parseCommentReference", <Object>["this", 5], "");
     SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         reference.identifier);
     expect(identifier.token, isNotNull);
@@ skipping 577 matching lines @@
         (obj) => obj is BlockFunctionBody,
         BlockFunctionBody,
         body);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is VariableDeclarationStatement,
         VariableDeclarationStatement,
         statement);
   }
 
-  void test_parseAwaitExpression_inSync() {
-    MethodDeclaration method = ParserTestCase.parse(
-        "parseClassMember",
-        <Object>["C"],
-        "m() { return await x + await y; }");
-    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 ReturnStatement,
-        ReturnStatement,
-        statement);
-    Expression expression = (statement as ReturnStatement).expression;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BinaryExpression,
-        BinaryExpression,
-        expression);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AwaitExpression,
-        AwaitExpression,
-        (expression as BinaryExpression).leftOperand);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AwaitExpression,
-        AwaitExpression,
-        (expression as BinaryExpression).rightOperand);
-  }
-
   void test_parseBitwiseAndExpression_normal() {
     BinaryExpression expression =
         ParserTestCase.parse4("parseBitwiseAndExpression", "x & y");
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.AMPERSAND);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseBitwiseAndExpression_super() {
@@ skipping 2032 matching lines @@
         FunctionExpression,
         invocation.function);
     FunctionExpression expression = invocation.function as FunctionExpression;
     expect(expression.parameters, isNotNull);
     expect(expression.body, isNotNull);
     ArgumentList list = invocation.argumentList;
     expect(list, isNotNull);
     expect(list.arguments, hasLength(1));
   }
 
+  void test_parseExpression_nonAwait() {
+    MethodInvocation expression = ParserTestCase.parseExpression("await()");
+    expect(expression.methodName.name, 'await');
+  }
+
   void test_parseExpression_superMethodInvocation() {
     MethodInvocation invocation =
         ParserTestCase.parse4("parseExpression", "super.m()");
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpressionList_multiple() {
     List<Expression> result =
@@ skipping 3124 matching lines @@
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser,
         methodName,
         <Object>[tokenStream],
         tokenStream) as Token;
   }
 }