[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 2579 matching lines @@
   NativeFunctionLiteral(Zone* zone, const AstRawString* name,
                         v8::Extension* extension, int pos)
       : Expression(zone, pos), name_(name), extension_(extension) {}
 
  private:
   const AstRawString* name_;
   v8::Extension* extension_;
 };
 
 
+class DoExpression final : public Expression {
+ public:
+  DECLARE_NODE_TYPE(DoExpression)
+
+  Scope* scope() { return scope_; }

[rossberg, 2015/10/12 13:52:39]

Why not just have a DoExpression carry a Block, instead of its own scope and
statements? That seems natural, and probably allows a bit more code reuse.
(TryStatement does the same, for example.)

[caitp (gmail), 2015/10/12 18:22:59]

Done

+  ZoneList<Statement*>* statements() { return statements_; }
+
+  static int num_ids() { return parent_num_ids() + 1; }
+  BailoutId EntryId() const { return BailoutId(local_id(0)); }
+  BailoutId ExitId() const { return BailoutId(local_id(1)); }
+  BailoutId DeclsId() const { return BailoutId(local_id(2)); }
+
+  VariableProxy* result() { return result_; }
+
+ protected:
+  DoExpression(Zone* zone, Scope* scope, ZoneList<Statement*>* statements,
+               VariableProxy* result, int pos)
+      : Expression(zone, pos),
+        scope_(scope),
+        statements_(statements),
+        result_(result) {
+    DCHECK_NOT_NULL(scope_);
+    DCHECK_NOT_NULL(statements_);
+    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; }
+
+  Scope* scope_;
+  ZoneList<Statement*>* statements_;
+  VariableProxy* result_;
+};
+
+
 class ThisFunction final : public Expression {
  public:
   DECLARE_NODE_TYPE(ThisFunction)
 
  protected:
   ThisFunction(Zone* zone, int pos) : Expression(zone, pos) {}
 };
 
 
 class SuperPropertyReference final : public Expression {
@@ skipping 848 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(Scope* scope, ZoneList<Statement*>* statements,
+                                int pos, int end_pos) {
+    Variable* result_var =
+        NewTemporaryVar(scope, ast_value_factory()->dot_result_string());
+    VariableProxy* result = NewVariableProxy(result_var, end_pos, end_pos);
+    return new (parser_zone_)
+        DoExpression(parser_zone_, scope, statements, 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 32 matching lines @@
  private:
   // This zone may be deallocated upon returning from parsing a function body
   // which we can guarantee is not going to be compiled or have its AST
   // inspected.
   // See ParseFunctionLiteral in parser.cc for preconditions.
   Zone* local_zone_;
   // ZoneObjects which need to persist until scope analysis must be allocated in
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
+
+  Variable* NewTemporaryVar(Scope* scope, const AstRawString* name);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_H_