Add spread rewriting

src/ast/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_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 906 matching lines @@
   // result.done
   Expression* result_done() const {
     return result_done_;
   }
 
   // each = result.value
   Expression* assign_each() const {
     return assign_each_;
   }
 
+  void set_assign_iterator(Expression* e) { assign_iterator_ = e; }
+  void set_next_result(Expression* e) { next_result_ = e; }
+  void set_result_done(Expression* e) { result_done_ = e; }
+  void set_assign_each(Expression* e) { assign_each_ = e; }
+
   BailoutId ContinueId() const override { return EntryId(); }
   BailoutId StackCheckId() const override { return BackEdgeId(); }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
 
  protected:
   ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : ForEachStatement(zone, labels, pos),
         assign_iterator_(NULL),
@@ skipping 738 matching lines @@
     int flags = depth() == 1 ? kShallowElements : kNoFlags;
     if (disable_mementos) {
       flags |= kDisableMementos;
     }
     if (is_strong()) {
       flags |= kIsStrong;
     }
     return flags;
   }
 
+  // Provide a mechanism for iterating through values to rewrite spreads.
+  ZoneList<Expression*>::iterator FirstSpread() const {
+    return (first_spread_index_ >= 0) ? values_->begin() + first_spread_index_
+                                      : values_->end();
+  }
+  ZoneList<Expression*>::iterator EndValue() const { return values_->end(); }
+
+  // Rewind an array literal omitting everything from the first spread on.
+  void RewindSpreads() {
+    values_->Rewind(first_spread_index_);
+    first_spread_index_ = -1;
+  }
+
   enum Flags {
     kNoFlags = 0,
     kShallowElements = 1,
     kDisableMementos = 1 << 1,
     kIsStrong = 1 << 2
   };
 
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache) override;
   FeedbackVectorSlot LiteralFeedbackSlot() const { return literal_slot_; }
@@ skipping 1683 matching lines @@
     stack_overflow_ = false;                                \
   }                                                         \
                                                             \
   uintptr_t stack_limit_;                                   \
   bool stack_overflow_
 
 #define DEFINE_AST_REWRITER_SUBCLASS_MEMBERS()        \
  public:                                              \
   AstNode* Rewrite(AstNode* node) {                   \
     DCHECK_NULL(replacement_);                        \
+    DCHECK_NOT_NULL(node);                            \
     Visit(node);                                      \
-    if (HasStackOverflow()) return nullptr;           \
+    if (HasStackOverflow()) return node;              \
     if (replacement_ == nullptr) return node;         \
     AstNode* result = replacement_;                   \
     replacement_ = nullptr;                           \
     return result;                                    \
   }                                                   \
                                                       \
  private:                                             \
   void InitializeAstRewriter(Isolate* isolate) {      \
     InitializeAstVisitor(isolate);                    \
     replacement_ = nullptr;                           \
@@ skipping 471 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_