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

src/parsing/parser-base.h

 // Copyright 2012 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 180 matching lines @@
   };
 
   struct TailCallExpression {
     TailCallExpression(ExpressionT expression, int pos)
         : expression(expression), pos(pos) {}
 
     ExpressionT expression;
     int pos;
   };
 
+  // Defines whether tail call expressions are allowed or not.
+  enum class ReturnExprContext {
+    // Tail call expressions are allowed.
+    kNormal,
+    // Tail call expressions are not allowed.
+    kInsideTryBlock,
+    kInsideForInOfBody,
+  };
+
   class FunctionState BASE_EMBEDDED {
    public:
     FunctionState(FunctionState** function_state_stack, Scope** scope_stack,
                   Scope* scope, FunctionKind kind,
                   typename Traits::Type::Factory* factory);
     ~FunctionState();
 
     int NextMaterializedLiteralIndex() {
       return next_materialized_literal_index_++;
     }
@@ skipping 41 matching lines @@
 
     const List<DestructuringAssignment>& destructuring_assignments_to_rewrite()
         const {
       return destructuring_assignments_to_rewrite_;
     }
 
     List<TailCallExpression>& expressions_in_tail_position() {
       return expressions_in_tail_position_;
     }
     void AddExpressionInTailPosition(ExpressionT expression, int pos) {
-      if (collect_expressions_in_tail_position_) {
+      if (return_expr_context() == ReturnExprContext::kNormal) {
         expressions_in_tail_position_.Add(TailCallExpression(expression, pos));
       }
     }
 
-    bool collect_expressions_in_tail_position() const {
-      return collect_expressions_in_tail_position_;
+    ReturnExprContext return_expr_context() const {
+      return return_expr_context_;
     }
-    void set_collect_expressions_in_tail_position(bool collect) {
-      collect_expressions_in_tail_position_ = collect;
+    void set_return_expr_context(ReturnExprContext context) {
+      return_expr_context_ = context;
     }
 
     ZoneList<ExpressionT>* non_patterns_to_rewrite() {
       return &non_patterns_to_rewrite_;
     }
 
     void next_function_is_parenthesized(bool parenthesized) {
       next_function_is_parenthesized_ = parenthesized;
     }
 
@@ skipping 35 matching lines @@
     // for generator functions to have this variable set.
     Variable* generator_object_variable_;
 
     FunctionState** function_state_stack_;
     FunctionState* outer_function_state_;
     Scope** scope_stack_;
     Scope* outer_scope_;
 
     List<DestructuringAssignment> destructuring_assignments_to_rewrite_;
     List<TailCallExpression> expressions_in_tail_position_;
-    bool collect_expressions_in_tail_position_;
+    ReturnExprContext return_expr_context_;
     ZoneList<ExpressionT> non_patterns_to_rewrite_;
 
     typename Traits::Type::Factory* factory_;
 
     // If true, the next (and immediately following) function literal is
     // preceded by a parenthesis.
     bool next_function_is_parenthesized_;
 
     // The value of the parents' next_function_is_parenthesized_, as it applies
     // to this function. Filled in by constructor.
     bool this_function_is_parenthesized_;
 
     friend class ParserTraits;
     friend class PreParserTraits;
     friend class Checkpoint;
   };
 
-  // This scope disables collecting of expressions at tail call position.
-  class DontCollectExpressionsInTailPositionScope {
+  // This scope sets current ReturnExprContext to given value.
+  class ReturnExprScope {
    public:
-    explicit DontCollectExpressionsInTailPositionScope(
-        FunctionState* function_state)
+    explicit ReturnExprScope(FunctionState* function_state,
+                             ReturnExprContext return_expr_context)
         : function_state_(function_state),
-          old_value_(function_state->collect_expressions_in_tail_position()) {
-      function_state->set_collect_expressions_in_tail_position(false);
+          sav_return_expr_context_(function_state->return_expr_context()) {
+      function_state->set_return_expr_context(return_expr_context);
     }
-    ~DontCollectExpressionsInTailPositionScope() {
-      function_state_->set_collect_expressions_in_tail_position(old_value_);
+    ~ReturnExprScope() {
+      function_state_->set_return_expr_context(sav_return_expr_context_);
     }
 
    private:
     FunctionState* function_state_;
-    bool old_value_;
+    ReturnExprContext sav_return_expr_context_;
   };
 
   // Collects all return expressions at tail call position in this scope
   // to a separate list.
   class CollectExpressionsInTailPositionToListScope {
    public:
     CollectExpressionsInTailPositionToListScope(FunctionState* function_state,
                                                 List<TailCallExpression>* list)
         : function_state_(function_state), list_(list) {
       function_state->expressions_in_tail_position().Swap(list_);
@@ skipping 255 matching lines @@
     Traits::ReportMessageAt(source_location, message, arg, error_type);
   }
 
   void ReportMessageAt(Scanner::Location location,
                        MessageTemplate::Template message,
                        ParseErrorType error_type = kSyntaxError) {
     Traits::ReportMessageAt(location, message, reinterpret_cast<const char*>(0),
                             error_type);
   }
 
+  void ReportIllegalTailCallAt(int pos, ReturnExprContext return_expr_context) {
+    Scanner::Location loc(pos, pos + 1);
+    MessageTemplate::Template msg = MessageTemplate::kNone;
+    switch (return_expr_context) {
+      case ReturnExprContext::kNormal:
+        UNREACHABLE();
+        return;
+      case ReturnExprContext::kInsideTryBlock:
+        msg = MessageTemplate::kTailCallInTryBlock;
+        break;
+      case ReturnExprContext::kInsideForInOfBody:
+        msg = MessageTemplate::kTailCallInForInOf;
+        break;
+    }
+    ReportMessageAt(loc, msg);
+  }
+
   void GetUnexpectedTokenMessage(
       Token::Value token, MessageTemplate::Template* message,
       Scanner::Location* location, const char** arg,
       MessageTemplate::Template default_ = MessageTemplate::kUnexpectedToken);
 
   void ReportUnexpectedToken(Token::Value token);
   void ReportUnexpectedTokenAt(
       Scanner::Location location, Token::Value token,
       MessageTemplate::Template message = MessageTemplate::kUnexpectedToken);
 
@@ skipping 337 matching lines @@
       expected_property_count_(0),
       this_location_(Scanner::Location::invalid()),
       return_location_(Scanner::Location::invalid()),
       super_location_(Scanner::Location::invalid()),
       kind_(kind),
       generator_object_variable_(NULL),
       function_state_stack_(function_state_stack),
       outer_function_state_(*function_state_stack),
       scope_stack_(scope_stack),
       outer_scope_(*scope_stack),
-      collect_expressions_in_tail_position_(true),
+      return_expr_context_(ReturnExprContext::kNormal),
       non_patterns_to_rewrite_(0, scope->zone()),
       factory_(factory),
       next_function_is_parenthesized_(false),
       this_function_is_parenthesized_(false) {
   *scope_stack_ = scope;
   *function_state_stack = this;
   if (outer_function_state_) {
     this_function_is_parenthesized_ =
         outer_function_state_->next_function_is_parenthesized_;
     outer_function_state_->next_function_is_parenthesized_ = false;
@@ skipping 2177 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H