Improvement on error reporting of 'for await' loops (#189)

* minor code readability improvements
* improves error reporting of 'for await' loops (#183)

Co-authored-by: Sébastien Ros <[email protected]>

Author: adams85

src/Esprima/JavascriptParser.cs

@@ -546,7 +546,6 @@ private void ConsumeSemicolon()
                 _lastMarker.Line = _startMarker.Line;
                 _lastMarker.Column = _startMarker.Column;
             }
-
         }
 
         // https://tc39.github.io/ecma262/#sec-primary-expression
@@ -2938,7 +2937,7 @@ private Statement ParseForStatement()
             var forIn = true;
             Node? left = null;
             Expression? right = null;
-            var _await = false;
+            var @await = false;
 
             var node = CreateNode();
             ExpectKeyword("for");
@@ -2948,14 +2947,19 @@ private Statement ParseForStatement()
                 {
                     TolerateUnexpectedToken(_lookahead);
                 }
-                _await = true;
+                @await = true;
                 NextToken();
             }
 
             Expect("(");
 
             if (Match(";"))
             {
+                if (@await)
+                {
+                    TolerateUnexpectedToken(_lookahead);
+                }
+
                 NextToken();
             }
             else
@@ -2971,8 +2975,13 @@ private Statement ParseForStatement()
                     var declarations = ParseVariableDeclarationList(ref inFor);
                     _context.AllowIn = previousAllowIn;
 
-                    if (!_await && declarations.Count == 1 && MatchKeyword("in"))
+                    if (declarations.Count == 1 && MatchKeyword("in"))
                     {
+                        if (@await)
+                        {
+                            TolerateUnexpectedToken(_lookahead);
+                        }
+
                         var decl = declarations[0];
                         if (decl.Init != null && (decl.Id.Type == Nodes.ArrayPattern || decl.Id.Type == Nodes.ObjectPattern || _context.Strict))
                         {
@@ -2994,6 +3003,11 @@ private Statement ParseForStatement()
                     }
                     else
                     {
+                        if (@await)
+                        {
+                            TolerateUnexpectedToken(_lookahead);
+                        }
+
                         init = Finalize(initNode, new VariableDeclaration(declarations, VariableDeclarationKind.Var));
                         Expect(";");
                     }
@@ -3005,6 +3019,11 @@ private Statement ParseForStatement()
                     var kind = ParseVariableDeclarationKind(kindString);
                     if (!_context.Strict && (string?) _lookahead.Value == "in")
                     {
+                        if (@await)
+                        {
+                            TolerateUnexpectedToken(_lookahead);
+                        }
+
                         left = Finalize(initNode, new Identifier(kindString));
                         NextToken();
                         right = ParseExpression();
@@ -3020,6 +3039,11 @@ private Statement ParseForStatement()
 
                         if (declarations.Count == 1 && declarations[0]!.Init == null && MatchKeyword("in"))
                         {
+                            if (@await)
+                            {
+                                TolerateUnexpectedToken(_lookahead);
+                            }
+
                             left = Finalize(initNode, new VariableDeclaration(declarations, kind));
                             NextToken();
                             right = ParseExpression();
@@ -3035,6 +3059,11 @@ private Statement ParseForStatement()
                         }
                         else
                         {
+                            if (@await)
+                            {
+                                TolerateUnexpectedToken(_lookahead);
+                            }
+
                             ConsumeSemicolon();
                             init = Finalize(initNode, new VariableDeclaration(declarations, kind));
                         }
@@ -3054,6 +3083,11 @@ private Statement ParseForStatement()
 
                     if (MatchKeyword("in"))
                     {
+                        if (@await)
+                        {
+                            TolerateUnexpectedToken(_lookahead);
+                        }
+
                         if (!_context.IsAssignmentTarget || init.Type == Nodes.AssignmentExpression)
                         {
                             TolerateError(Messages.InvalidLHSInForIn);
@@ -3081,6 +3115,11 @@ private Statement ParseForStatement()
                     }
                     else
                     {
+                        if (@await)
+                        {
+                            TolerateUnexpectedToken(_lookahead);
+                        }
+
                         // The `init` node was not parsed isolated, but we would have wanted it to.
                         _context.IsBindingElement = previousIsBindingElement;
                         _context.IsAssignmentTarget = previousIsAssignmentTarget;
@@ -3135,8 +3174,8 @@ private Statement ParseForStatement()
             return left == null
                 ? Finalize(node, new ForStatement(init, test, update, body))
                 : forIn
-                    ? Finalize(node, new ForInStatement(left, right!, body))
-                    : Finalize(node, new ForOfStatement(left, right!, body, _await));
+                    ? (Statement) Finalize(node, new ForInStatement(left, right!, body))
+                    : Finalize(node, new ForOfStatement(left, right!, body, @await));
         }
 
         // https://tc39.github.io/ecma262/#sec-continue-statement

test/Esprima.Tests/ParserTests.cs

@@ -202,5 +202,43 @@ public void ThrowsErrorForDuplicateProto()
             var parser = new JavaScriptParser("if({ __proto__: [], __proto__: [] } instanceof Array) {}", new ParserOptions { Tolerant = false });
             Assert.Throws<ParserException>(() => parser.ParseScript());
         }
+
+        [Theory]
+        [InlineData("(async () => { for await (var x of []) { } })()")]
+        [InlineData("(async () => { for await (let x of []) { } })()")]
+        [InlineData("(async () => { for await (const x of []) { } })()")]
+        [InlineData("(async () => { for await (x of []) { } })()")]
+        public void ParsesValidForAwaitLoops(string code)
+        {
+            var errorHandler = new CollectingErrorHandler();
+            var parser = new JavaScriptParser(code, new ParserOptions { Tolerant = true, ErrorHandler = errorHandler });
+            parser.ParseScript();
+
+            Assert.False(errorHandler.Errors.Any());
+        }
+
+        [Theory]
+        [InlineData("(async () => { for await (;;) { } })()")]
+        [InlineData("(async () => { for await (var i = 0, j = 1;;) { } })()")]
+        [InlineData("(async () => { for await (let i = 0, j = 1;;) { } })()")]
+        [InlineData("(async () => { for await (const i = 0, j = 1;;) { } })()")]
+        [InlineData("(async () => { for await (i = 0, j = 1;;) { } })()")]
+        [InlineData("(async () => { for await (var x = (0 in []) in {}) { } })()")]
+        [InlineData("(async () => { for await (let x in {}) { } })()")]
+        [InlineData("(async () => { for await (const x in {}) { } })()")]
+        [InlineData("(async () => { for await (let in {}) { } })()")]
+        [InlineData("(async () => { for await (const in {}) { } })()")]
+        [InlineData("(async () => { for await (x in {}) { } })()")]
+        public void ToleratesInvalidForAwaitLoops(string code)
+        {
+            var errorHandler = new CollectingErrorHandler();
+            var parser = new JavaScriptParser(code, new ParserOptions { Tolerant = true, ErrorHandler = errorHandler });
+            parser.ParseScript();
+
+            Assert.True(errorHandler.Errors.Any());
+
+            parser = new JavaScriptParser(code, new ParserOptions { Tolerant = false });
+            Assert.Throws<ParserException>(() => parser.ParseScript());
+        }
     }
 }