[es7] implement |do| expressions proposal

src/rewriter.cc

 // 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.
 
 #include "src/rewriter.h"
 
 #include "src/ast.h"
 #include "src/parser.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 
 class Processor: public AstVisitor {
  public:
   Processor(Isolate* isolate, Scope* scope, Variable* result,
             AstValueFactory* ast_value_factory)
       : result_(result),
         result_assigned_(false),
         replacement_(nullptr),
         is_set_(false),
         scope_(scope),
         factory_(ast_value_factory) {
     InitializeAstVisitor(isolate, ast_value_factory->zone());
   }
 
+  Processor(Parser* parser, Scope* scope, Variable* result,
+            AstValueFactory* ast_value_factory)
+      : result_(result),
+        result_assigned_(false),
+        replacement_(nullptr),
+        is_set_(false),
+        scope_(scope),
+        factory_(ast_value_factory) {
+    InitializeAstVisitor(nullptr, ast_value_factory->zone());
+    parser_ = parser;
+  }
+
   virtual ~Processor() { }
 
   void Process(ZoneList<Statement*>* statements);
   bool result_assigned() const { return result_assigned_; }
 
   Scope* scope() { return scope_; }
   AstNodeFactory* factory() { return &factory_; }
 
  private:
   Variable* result_;
@@ skipping 28 matching lines @@
   // Inserts '.result = undefined' in front of the given statement.
   Statement* AssignUndefinedBefore(Statement* s);
 
   // Node visitors.
 #define DEF_VISIT(type) virtual void Visit##type(type* node) override;
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
   void VisitIterationStatement(IterationStatement* stmt);
 
-  DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();

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

I think Adam is working on a refactoring for separating AstVisitor from Isolate.

[caitp (gmail), 2015/10/12 18:23:00]

If that lands first, that would be helpful.

[adamk, 2015/10/12 19:02:21]

I was hoping to get some answers on my v8-dev thread
(https://groups.google.com/d/msg/v8-dev/NnbGtwMgwOk/WT91HW7SCQAJ) but barring
that I'll be in MUC this week so will find out in person what the best way
forward here is. My refactoring is not likely to be real far off in
functionality from what you've got here, but will obviously involve less code
duplication.

+ 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 (isolate_) {
+      StackLimitCheck check(isolate_);
+      if (!check.HasOverflowed()) return false;
+      stack_overflow_ = true;
+    } else {
+      if (!parser_->CheckStackOverflow()) return false;
+      stack_overflow_ = true;
+    }
+    return true;
+  }
+
+ private:
+  void InitializeAstVisitor(Isolate* isolate, Zone* zone) {
+    isolate_ = isolate;
+    zone_ = zone;
+    stack_overflow_ = false;
+  }
+  Zone* zone() { return zone_; }
+  Isolate* isolate() { return isolate_; }
+
+  Isolate* isolate_;
+  Parser* parser_;
+  Zone* zone_;
+  bool stack_overflow_;
 };
 
 
 Statement* Processor::AssignUndefinedBefore(Statement* s) {
   Expression* result_proxy = factory()->NewVariableProxy(result_);
   Expression* undef = factory()->NewUndefinedLiteral(RelocInfo::kNoPosition);
   Expression* assignment = factory()->NewAssignment(
       Token::ASSIGN, result_proxy, undef, RelocInfo::kNoPosition);
   Block* b = factory()->NewBlock(NULL, 2, false, RelocInfo::kNoPosition);
   b->statements()->Add(
@@ skipping 266 matching lines @@
       Statement* result_statement =
           processor.factory()->NewReturnStatement(result_proxy, pos);
       body->Add(result_statement, info->zone());
     }
   }
 
   return true;
 }
 
 
+bool Rewriter::Rewrite(Parser* parser, DoExpression* expr,
+                       AstValueFactory* factory) {
+  Scope* scope = expr->scope();
+  ZoneList<Statement*>* body = expr->statements();
+  VariableProxy* result = expr->result();
+  Variable* result_var = result->var();
+
+  if (!body->is_empty()) {
+    Processor processor(parser, scope, result_var, factory);
+    processor.Process(body);
+    if (processor.HasStackOverflow()) return false;
+
+    if (processor.result_assigned()) {
+      DCHECK(!result->is_assigned());
+      result->set_is_assigned();
+    }
+  }
+  return true;
+}
+
+
 }  // namespace internal
 }  // namespace v8