[es8] Prepare explicit tail calls (STC) for staging with implicit tail calls (PTC).

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 176 matching lines @@
     DestructuringAssignment(ExpressionT expression, Scope* scope)
         : assignment(expression), scope(scope) {}
 
     ExpressionT assignment;
     Scope* scope;
   };
 
   class TailCallExpressionList {
    public:
     explicit TailCallExpressionList(Zone* zone)
-        : zone_(zone), expressions_(0, zone) {}
+        : zone_(zone), expressions_(0, zone), has_explicit_tail_calls_(false) {}
 
     const ZoneList<ExpressionT>& expressions() const { return expressions_; }
     const Scanner::Location& location() const { return loc_; }
 
-    bool is_empty() const { return expressions_.is_empty(); }
+    bool has_explicit_tail_calls() const { return has_explicit_tail_calls_; }
 
     void Swap(TailCallExpressionList& other) {
       expressions_.Swap(&other.expressions_);
       std::swap(loc_, other.loc_);
+      std::swap(has_explicit_tail_calls_, other.has_explicit_tail_calls_);
     }
 
-    void Add(ExpressionT expr, const Scanner::Location& loc) {
-      if (expressions_.is_empty()) loc_ = loc;
+    void AddImplicitTailCall(ExpressionT expr) {
+      expressions_.Add(expr, zone_);
+    }
+
+    void AddExplicitTailCall(ExpressionT expr, const Scanner::Location& loc) {
+      if (!has_explicit_tail_calls()) {
+        loc_ = loc;
+        has_explicit_tail_calls_ = true;
+      }
       expressions_.Add(expr, zone_);
     }
 
     void Append(const TailCallExpressionList& other) {
-      if (expressions_.is_empty()) loc_ = other.loc_;
+      if (!has_explicit_tail_calls()) {
+        loc_ = other.loc_;
+        has_explicit_tail_calls_ = other.has_explicit_tail_calls_;
+      }
       expressions_.AddAll(other.expressions_, zone_);
     }
 
    private:
     Zone* zone_;
     ZoneList<ExpressionT> expressions_;
     Scanner::Location loc_;
+    bool has_explicit_tail_calls_;
   };
 
   // Defines whether tail call expressions are allowed or not.
   enum class ReturnExprContext {
     // We are inside return statement which is allowed to contain tail call
     // expressions. Tail call expressions are allowed.
     kInsideValidReturnStatement,
 
     // We are inside a block in which tail call expressions are allowed but
     // not yet inside a return statement.
@@ skipping 57 matching lines @@
     typename Traits::Type::Factory* factory() { return factory_; }
 
     const List<DestructuringAssignment>& destructuring_assignments_to_rewrite()
         const {
       return destructuring_assignments_to_rewrite_;
     }
 
     TailCallExpressionList& tail_call_expressions() {
       return tail_call_expressions_;
     }
-    void AddExpressionInTailPosition(ExpressionT expression,
-                                     const Scanner::Location& loc) {
-      // If only FLAG_harmony_explicit_tailcalls is enabled then expression
-      // must be a Call expression.
-      DCHECK(FLAG_harmony_tailcalls || !FLAG_harmony_explicit_tailcalls ||
-             expression->IsCall());
+    void AddImplicitTailCallExpression(ExpressionT expression) {
       if (return_expr_context() ==
           ReturnExprContext::kInsideValidReturnStatement) {
-        tail_call_expressions_.Add(expression, loc);
+        tail_call_expressions_.AddImplicitTailCall(expression);
+      }
+    }
+    void AddExplicitTailCallExpression(ExpressionT expression,
+                                       const Scanner::Location& loc) {
+      DCHECK(expression->IsCall());
+      if (return_expr_context() ==
+          ReturnExprContext::kInsideValidReturnStatement) {
+        tail_call_expressions_.AddExplicitTailCall(expression, loc);
       }
     }
 
     ReturnExprContext return_expr_context() const {
       return return_expr_context_;
     }
     void set_return_expr_context(ReturnExprContext context) {
       return_expr_context_ = context;
     }
 
@@ skipping 1943 matching lines @@
       case ReturnExprContext::kInsideForInOfBody:
         msg = MessageTemplate::kUnexpectedTailCallInForInOf;
         break;
     }
     ReportMessageAt(loc, msg);
     *ok = false;
     return Traits::EmptyExpression();
   }
   classifier->RecordTailCallExpressionError(
       loc, MessageTemplate::kUnexpectedTailCall);
-  function_state_->AddExpressionInTailPosition(expression, loc);
+  function_state_->AddExplicitTailCallExpression(expression, loc);
   return expression;
 }
 
 // Precedence = 3
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseConditionalExpression(bool accept_IN,
                                                ExpressionClassifier* classifier,
                                                bool* ok) {
   // ConditionalExpression ::
@@ skipping 1039 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H