Don't fail on async comprehension syntax

Author: slozier

src/core/IronPython/Compiler/Parser.cs

@@ -2340,7 +2340,7 @@ private IReadOnlyList<Node> FinishArgListOrGenExpr() {
 
                 if (MaybeEat(TokenKind.Assign)) {               //  Keyword argument
                     a = FinishKeywordArgument(e);
-                } else if (PeekToken(TokenKind.KeywordFor)) {    //  Generator expression
+                } else if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {    //  Generator expression
                     a = ParseGeneratorExpression(e);
                     Eat(TokenKind.RightParenthesis);
                     a.SetLoc(_globalParent, start, GetEnd());
@@ -2599,7 +2599,7 @@ private Expression FinishTupleOrGenExp() {
                     if (MaybeEat(TokenKind.Comma)) {
                         // "(" expression "," ...
                         ret = FinishExpressionListAsExpr(expr);
-                    } else if (PeekToken(TokenKind.KeywordFor)) {
+                    } else if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {
                         // "(" expression "for" ...
                         if (expr is StarredExpression) ReportSyntaxError(expr.StartIndex, expr.EndIndex, "iterable unpacking cannot be used in comprehension");
                         ret = ParseGeneratorExpression(expr);
@@ -2634,7 +2634,7 @@ private Expression ParseGeneratorExpression(Expression expr) {
             Statement current = root;
 
             for (; ; ) {
-                if (PeekToken(TokenKind.KeywordFor)) {
+                if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {
                     current = NestGenExpr(current, ParseGenExprFor());
                 } else if (PeekToken(TokenKind.KeywordIf)) {
                     current = NestGenExpr(current, ParseGenExprIf());
@@ -2684,6 +2684,14 @@ private static Statement NestGenExpr(Statement current, Statement nested) {
 
         // "for" exprlist "in" or_test
         private ForStatement ParseGenExprFor() {
+            var isAsync = MaybeEat(TokenKind.KeywordAsync);
+            if (isAsync) {
+                FunctionDefinition current = CurrentFunction;
+                if (current is null || !current.IsAsync) {
+                    ReportSyntaxError("'asynchronous comprehension outside of an asynchronous function");
+                }
+            }
+
             var start = GetStart();
             Eat(TokenKind.KeywordFor);
             bool trailingComma;
@@ -2754,7 +2762,7 @@ private Expression FinishDictOrSetValue() {
                         }
                         var expr = ParseStarExpr();
 
-                        if (PeekToken(TokenKind.KeywordFor)) {
+                        if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {
                             if (!first) ReportSyntaxError("invalid syntax");
                         }
 
@@ -2770,7 +2778,7 @@ private Expression FinishDictOrSetValue() {
                             }
                             Expression e2 = ParseTest();
 
-                            if (PeekToken(TokenKind.KeywordFor)) {
+                            if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {
                                 if (!first) {
                                     ReportSyntaxError("invalid syntax");
                                 }
@@ -2788,7 +2796,7 @@ private Expression FinishDictOrSetValue() {
                                 first = true;
                             }
 
-                            if (PeekToken(TokenKind.KeywordFor)) {
+                            if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {
                                 if (!first) {
                                     ReportSyntaxError("invalid syntax");
                                 }
@@ -2876,7 +2884,7 @@ private ComprehensionIterator[] ParseCompIter() {
             iters.Add(firstFor);
 
             while (true) {
-                if (PeekToken(TokenKind.KeywordFor)) {
+                if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {
                     iters.Add(ParseCompFor());
                 } else if (PeekToken(TokenKind.KeywordIf)) {
                     iters.Add(ParseCompIf());
@@ -2890,6 +2898,13 @@ private ComprehensionIterator[] ParseCompIter() {
 
         // comp_for: 'for' exprlist 'in' or_test [comp_iter]
         private ComprehensionFor ParseCompFor() {
+            var isAsync = MaybeEat(TokenKind.KeywordAsync);
+            if (isAsync) {
+                FunctionDefinition current = CurrentFunction;
+                if (current is null || !current.IsAsync) {
+                    ReportSyntaxError("'asynchronous comprehension outside of an asynchronous function");
+                }
+            }
             Eat(TokenKind.KeywordFor);
             var start = GetStart();
             bool trailingComma;
@@ -2934,7 +2949,7 @@ private Expression FinishListValue() {
                     // (comp_for | (',' (test|star_expr))* [','] )
 
                     // comp_for
-                    if (PeekToken(TokenKind.KeywordFor)) {
+                    if (PeekToken(TokenKind.KeywordFor) || PeekToken(TokenKind.KeywordAsync)) {
                         // although it's calling ParseCompIter(), because the peek token is a FOR it is going to
                         // do the right thing.
                         if (expr is StarredExpression) ReportSyntaxError(expr.StartIndex, expr.EndIndex, "iterable unpacking cannot be used in comprehension");
@@ -3033,6 +3048,7 @@ private static bool NeverTestToken(Token t) {
                 case TokenKind.KeywordFor:
                 case TokenKind.KeywordIn:
                 case TokenKind.KeywordIf:
+                case TokenKind.KeywordAsync:
                     return true;
 
                 default: return false;