[es7] implement |do| expressions proposal

src/ast.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_AST_H_
 #define V8_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast-value-factory.h"
 #include "src/bailout-reason.h"
@@ skipping 72 matching lines @@
   V(CallRuntime)                \
   V(UnaryOperation)             \
   V(CountOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
   V(Spread)                     \
   V(ThisFunction)               \
   V(SuperPropertyReference)     \
   V(SuperCallReference)         \
   V(CaseClause)                 \
-  V(EmptyParentheses)
+  V(EmptyParentheses)           \
+  V(DoExpression)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstNodeFactory;
 class AstVisitor;
 class Declaration;
@@ skipping 379 matching lines @@
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   ZoneList<Statement*> statements_;
   bool ignore_completion_value_;
   Scope* scope_;
 };
 
 
+class DoExpression final : public Expression {
+ public:
+  DECLARE_NODE_TYPE(DoExpression)
+
+  Block* block() { return block_; }
+  VariableProxy* result() { return result_; }
+
+ protected:
+  DoExpression(Zone* zone, Block* block, VariableProxy* result, int pos)
+      : Expression(zone, pos), block_(block), result_(result) {
+    DCHECK_NOT_NULL(block_);
+    DCHECK_NOT_NULL(result_);
+  }
+  static int parent_num_ids() { return Expression::num_ids(); }
+
+ private:
+  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+  Block* block_;
+  VariableProxy* result_;
+};
+
+
 class Declaration : public AstNode {
  public:
   VariableProxy* proxy() const { return proxy_; }
   VariableMode mode() const { return mode_; }
   Scope* scope() const { return scope_; }
   virtual InitializationFlag initialization() const = 0;
   virtual bool IsInlineable() const;
 
  protected:
   Declaration(Zone* zone, VariableProxy* proxy, VariableMode mode, Scope* scope,
@@ skipping 2660 matching lines @@
   virtual void VisitExpressions(ZoneList<Expression*>* expressions);
 
   // Individual AST nodes.
 #define DEF_VISIT(type)                         \
   virtual void Visit##type(type* node) = 0;
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 };
 
 
-#define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS()               \
- public:                                                    \
-  void Visit(AstNode* node) final {                         \
-    if (!CheckStackOverflow()) node->Accept(this);          \
-  }                                                         \
-                                                            \
-  void SetStackOverflow() { stack_overflow_ = true; }       \
-  void ClearStackOverflow() { stack_overflow_ = false; }    \
-  bool HasStackOverflow() const { return stack_overflow_; } \
-                                                            \
-  bool CheckStackOverflow() {                               \
-    if (stack_overflow_) return true;                       \
-    if (GetCurrentStackPosition() < stack_limit_) {         \
-      stack_overflow_ = true;                               \
-      return true;                                          \
-    }                                                       \
-    return false;                                           \
-  }                                                         \
-                                                            \
- private:                                                   \
-  void InitializeAstVisitor(Isolate* isolate, Zone* zone) { \
-    zone_ = zone;                                           \
-    stack_limit_ = isolate->stack_guard()->real_climit();   \
-    stack_overflow_ = false;                                \
-  }                                                         \
-  Zone* zone() { return zone_; }                            \
-                                                            \
-  Zone* zone_;                                              \
-  uintptr_t stack_limit_;                                   \
+#define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS()                    \
+ public:                                                         \
+  void Visit(AstNode* node) final {                              \
+    if (!CheckStackOverflow()) node->Accept(this);               \
+  }                                                              \
+                                                                 \
+  void SetStackOverflow() { stack_overflow_ = true; }            \
+  void ClearStackOverflow() { stack_overflow_ = false; }         \
+  bool HasStackOverflow() const { return stack_overflow_; }      \
+                                                                 \
+  bool CheckStackOverflow() {                                    \
+    if (stack_overflow_) return true;                            \
+    if (GetCurrentStackPosition() < stack_limit_) {              \
+      stack_overflow_ = true;                                    \
+      return true;                                               \
+    }                                                            \
+    return false;                                                \
+  }                                                              \
+                                                                 \
+ private:                                                        \
+  void InitializeAstVisitor(Isolate* isolate, Zone* zone) {      \
+    zone_ = zone;                                                \
+    stack_limit_ = isolate->stack_guard()->real_climit();        \
+    stack_overflow_ = false;                                     \
+  }                                                              \
+  void InitializeAstVisitor(uintptr_t stack_limit, Zone* zone) { \
+    zone_ = zone;                                                \
+    stack_limit_ = stack_limit;                                  \
+    stack_overflow_ = false;                                     \
+  }                                                              \
+  Zone* zone() { return zone_; }                                 \
+                                                                 \
+  Zone* zone_;                                                   \
+  uintptr_t stack_limit_;                                        \
   bool stack_overflow_
 
 
 // ----------------------------------------------------------------------------
 // AstNode factory
 
 class AstNodeFactory final BASE_EMBEDDED {
  public:
   explicit AstNodeFactory(AstValueFactory* ast_value_factory)
       : local_zone_(ast_value_factory->zone()),
@@ skipping 365 matching lines @@
                      properties, start_position, end_position);
   }
 
   NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
                                                   v8::Extension* extension,
                                                   int pos) {
     return new (parser_zone_)
         NativeFunctionLiteral(parser_zone_, name, extension, pos);
   }
 
+  DoExpression* NewDoExpression(Block* block, Variable* result_var, int pos) {
+    VariableProxy* result = NewVariableProxy(result_var, pos);
+    return new (parser_zone_) DoExpression(parser_zone_, block, result, pos);
+  }
+
   ThisFunction* NewThisFunction(int pos) {
     return new (local_zone_) ThisFunction(local_zone_, pos);
   }
 
   SuperPropertyReference* NewSuperPropertyReference(VariableProxy* this_var,
                                                     Expression* home_object,
                                                     int pos) {
     return new (parser_zone_)
         SuperPropertyReference(parser_zone_, this_var, home_object, pos);
   }
@@ skipping 39 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_H_