[es7] implement |do| expressions proposal

src/parser.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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // TODO(titzer): remove this include dependency
@@ skipping 795 matching lines @@
       int function_token_position, FunctionLiteral::FunctionType type,
       FunctionLiteral::ArityRestriction arity_restriction,
       LanguageMode language_mode, bool* ok);
   V8_INLINE void SkipLazyFunctionBody(
       int* materialized_literal_count, int* expected_property_count, bool* ok,
       Scanner::BookmarkScope* bookmark = nullptr);
   V8_INLINE ZoneList<Statement*>* ParseEagerFunctionBody(
       const AstRawString* name, int pos,
       const ParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
+  V8_INLINE ZoneList<Statement*>* ParseStatementList(Token::Value end_token,
+                                                     bool* ok);
 
   ClassLiteral* ParseClassLiteral(const AstRawString* name,
                                   Scanner::Location class_name_location,
                                   bool name_is_strict_reserved, int pos,
                                   bool* ok);
 
+  inline void RewriteDoExpression(Expression* expr, bool* ok);
+
   V8_INLINE void CheckConflictingVarDeclarations(v8::internal::Scope* scope,
                                                  bool* ok);
 
   class TemplateLiteral : public ZoneObject {
    public:
     TemplateLiteral(Zone* zone, int pos)
         : cooked_(8, zone), raw_(8, zone), expressions_(8, zone), pos_(pos) {}
 
     const ZoneList<Expression*>* cooked() const { return &cooked_; }
     const ZoneList<Expression*>* raw() const { return &raw_; }
@@ skipping 265 matching lines @@
   // Initialize the components of a for-in / for-of statement.
   void InitializeForEachStatement(ForEachStatement* stmt,
                                   Expression* each,
                                   Expression* subject,
                                   Statement* body);
   Statement* DesugarLexicalBindingsInForStatement(
       Scope* inner_scope, bool is_const, ZoneList<const AstRawString*>* names,
       ForStatement* loop, Statement* init, Expression* cond, Statement* next,
       Statement* body, bool* ok);
 
+  void RewriteDoExpression(Expression* expr, bool* ok);
+
   FunctionLiteral* ParseFunctionLiteral(
       const AstRawString* name, Scanner::Location function_name_location,
       FunctionNameValidity function_name_validity, FunctionKind kind,
       int function_token_position, FunctionLiteral::FunctionType type,
       FunctionLiteral::ArityRestriction arity_restriction,
       LanguageMode language_mode, bool* ok);
 
 
   ClassLiteral* ParseClassLiteral(const AstRawString* name,
                                   Scanner::Location class_name_location,
@@ skipping 124 matching lines @@
 }
 
 
 ZoneList<Statement*>* ParserTraits::ParseEagerFunctionBody(
     const AstRawString* name, int pos, const ParserFormalParameters& parameters,
     FunctionKind kind, FunctionLiteral::FunctionType function_type, bool* ok) {
   return parser_->ParseEagerFunctionBody(name, pos, parameters, kind,
                                          function_type, ok);
 }
 
+
+ZoneList<Statement*>* ParserTraits::ParseStatementList(Token::Value end_token,
+                                                       bool* ok) {
+  ZoneList<Statement*>* statements =
+      new (parser_->zone()) ZoneList<Statement*>(16, parser_->zone());
+  parser_->ParseStatementList(statements, end_token, ok);
+  return statements;
+}
+
+
 void ParserTraits::CheckConflictingVarDeclarations(v8::internal::Scope* scope,
                                                    bool* ok) {
   parser_->CheckConflictingVarDeclarations(scope, ok);
 }
 
 
 // Support for handling complex values (array and object literals) that
 // can be fully handled at compile time.
 class CompileTimeValue: public AllStatic {
  public:
@@ skipping 109 matching lines @@
     ZoneList<v8::internal::Statement*>* body, bool* ok) {
   if (!parameters.is_simple) {
     auto* init_block =
         parser_->BuildParameterInitializationBlock(parameters, ok);
     if (!*ok) return;
     if (init_block != nullptr) {
       body->Add(init_block, parser_->zone());
     }
   }
 }
+
+
+void ParserTraits::RewriteDoExpression(Expression* expr, bool* ok) {
+  return parser_->RewriteDoExpression(expr, ok);
+}
+
+
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSER_H_