[destructuring] Implement spread binding patterns.

src/pattern-rewriter.cc

 // Copyright 2015 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/ast.h"
 #include "src/messages.h"
 #include "src/parser.h"
 
 namespace v8 {
 
@@ skipping 228 matching lines @@
 }
 
 
 void Parser::PatternRewriter::VisitArrayLiteral(ArrayLiteral* node) {
   auto iterator = CreateTempVar(
       descriptor_->parser->GetIterator(current_value_, factory()));
   auto done = CreateTempVar(
       factory()->NewBooleanLiteral(false, RelocInfo::kNoPosition));
   auto result = CreateTempVar();
   auto v = CreateTempVar();
+
+  Spread* spread = nullptr;
   for (Expression* value : *node->values()) {
+    if (value->IsSpread()) {
+      spread = value->AsSpread();
+      break;
+    }
+
     // if (!done) {
     //   result = IteratorNext(iterator);
     //   v = (done = result.done) ? undefined : result.value;
     // }
     auto next_block =
         factory()->NewBlock(nullptr, 2, true, RelocInfo::kNoPosition);
     next_block->AddStatement(factory()->NewExpressionStatement(
                                  descriptor_->parser->BuildIteratorNextResult(
                                      factory()->NewVariableProxy(iterator),
                                      result, RelocInfo::kNoPosition),
@@ skipping 29 matching lines @@
                                      factory()->NewVariableProxy(done),
                                      RelocInfo::kNoPosition),
         next_block, factory()->NewEmptyStatement(RelocInfo::kNoPosition),
         RelocInfo::kNoPosition);
     block_->AddStatement(if_statement, zone());
 
     if (!(value->IsLiteral() && value->AsLiteral()->raw_value()->IsTheHole())) {
       RecurseIntoSubpattern(value, factory()->NewVariableProxy(v));
     }
   }
+
+  if (spread != nullptr) {
+    // array = [];

[arv (Not doing code reviews), 2015/05/20 13:58:05]

Lets change this to not create the array here and have the runtime funciton
create the array. Then we do not need to add the literal_index to ast node.

[Dmitry Lomov (no reviews), 2015/05/20 14:07:19]

We definitely want to create an array here, to benefit from allocation site
tracking optimizations

+    // if (!done) $spreadIntoArray(array, iterator);
+    auto empty_exprs = new (zone()) ZoneList<Expression*>(0, zone());
+    auto array = CreateTempVar(factory()->NewArrayLiteral(
+        empty_exprs, spread->literal_index(),
+        is_strong(descriptor_->parser->language_mode()),
+        RelocInfo::kNoPosition));
+
+    auto arguments = new (zone()) ZoneList<Expression*>(2, zone());
+    arguments->Add(factory()->NewVariableProxy(array), zone());
+    arguments->Add(factory()->NewVariableProxy(iterator), zone());
+    auto spread_into_array_call = factory()->NewCallRuntime(
+        ast_value_factory()->spread_into_array_string(), nullptr, arguments,
+        RelocInfo::kNoPosition);
+
+    auto if_statement = factory()->NewIfStatement(
+        factory()->NewUnaryOperation(Token::NOT,
+                                     factory()->NewVariableProxy(done),
+                                     RelocInfo::kNoPosition),
+        factory()->NewExpressionStatement(spread_into_array_call,
+                                          RelocInfo::kNoPosition),
+        factory()->NewEmptyStatement(RelocInfo::kNoPosition),
+        RelocInfo::kNoPosition);
+    block_->AddStatement(if_statement, zone());
+
+
+    RecurseIntoSubpattern(spread->expression(),
+                          factory()->NewVariableProxy(array));
+  }
 }
 
 
 void Parser::PatternRewriter::VisitAssignment(Assignment* node) {
   // let {<pattern> = <init>} = <value>
   //   becomes
   // temp = <value>;
   // <pattern> = temp === undefined ? <init> : temp;
   DCHECK(node->op() == Token::ASSIGN);
   auto temp = CreateTempVar(current_value_);
@@ skipping 59 matching lines @@
 NOT_A_PATTERN(TryFinallyStatement)
 NOT_A_PATTERN(UnaryOperation)
 NOT_A_PATTERN(VariableDeclaration)
 NOT_A_PATTERN(WhileStatement)
 NOT_A_PATTERN(WithStatement)
 NOT_A_PATTERN(Yield)
 
 #undef NOT_A_PATTERN
 }
 }  // namespace v8::internal