[es8] Report proper syntax error for tail call expressions in for-in and for-of bodies.

src/parsing/preparser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 675 matching lines @@
     Consume(Token::CONTINUE);
     tail_call_position = position();
     tok = peek();
   }
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON &&
       tok != Token::RBRACE &&
       tok != Token::EOS) {
     ParseExpression(true, CHECK_OK);
     if (tail_call_position >= 0) {
-      if (!function_state_->collect_expressions_in_tail_position()) {
-        Scanner::Location loc(tail_call_position, tail_call_position + 1);
-        ReportMessageAt(loc, MessageTemplate::kTailCallInTryBlock);
+      ReturnExprContext return_expr_context =
+          function_state_->return_expr_context();
+      if (return_expr_context != ReturnExprContext::kNormal) {
+        ReportIllegalTailCallAt(tail_call_position, return_expr_context);
         *ok = false;
         return Statement::Default();
       }
       function_state_->AddExpressionInTailPosition(
           PreParserExpression::Default(), tail_call_position);
     }
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::Jump();
 }
@@ skipping 134 matching lines @@
 
         if (mode == ForEachStatement::ITERATE) {
           ExpressionClassifier classifier(this);
           ParseAssignmentExpression(true, &classifier, CHECK_OK);
           RewriteNonPattern(&classifier, CHECK_OK);
         } else {
           ParseExpression(true, CHECK_OK);
         }
 
         Expect(Token::RPAREN, CHECK_OK);
-        ParseScopedStatement(true, CHECK_OK);
+        {
+          ReturnExprScope no_tail_calls(function_state_,
+                                        ReturnExprContext::kInsideForInOfBody);
+          ParseScopedStatement(true, CHECK_OK);
+        }
         return Statement::Default();
       }
     } else {
       int lhs_beg_pos = peek_position();
       ExpressionClassifier classifier(this);
       Expression lhs = ParseExpression(false, &classifier, CHECK_OK);
       int lhs_end_pos = scanner()->location().end_pos;
       bool is_for_each = CheckInOrOf(&mode, ok);
       if (!*ok) return Statement::Default();
       bool is_destructuring = is_for_each &&
@@ skipping 82 matching lines @@
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
   //
   // Finally ::
   //   'finally' Block
 
   Expect(Token::TRY, CHECK_OK);
 
   {
-    DontCollectExpressionsInTailPositionScope no_tail_calls(function_state_);
+    ReturnExprScope no_tail_calls(function_state_,
+                                  ReturnExprContext::kInsideTryBlock);
     ParseBlock(CHECK_OK);
   }
 
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessageAt(scanner()->location(), MessageTemplate::kNoCatchOrFinally);
     *ok = false;
     return Statement::Default();
   }
   List<TailCallExpression> expressions_in_tail_position_in_catch_block;
@@ skipping 225 matching lines @@
   }
   Expect(Token::RBRACE, CHECK_OK);
   return PreParserExpression::Default();
 }
 
 #undef CHECK_OK
 
 
 }  // namespace internal
 }  // namespace v8