WIP: Implement ES6 Spread-calls

src/compiler/ast-graph-builder.cc

 // Copyright 2014 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/compiler/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/linkage.h"
@@ skipping 2207 matching lines @@
   VisitForValue(expr->left());
   VisitForValue(expr->right());
   Node* right = environment()->Pop();
   Node* left = environment()->Pop();
   Node* value = NewNode(op, left, right);
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   ast_context()->ProduceValue(value);
 }
 
 
+void AstGraphBuilder::VisitSpreadOperation(SpreadOperation* expr) {
+  LoopBuilder for_loop(this);
+  VisitForEffect(expr->assign_iterator());
+  for_loop.BeginLoop(NULL, false);
+  VisitForEffect(expr->next_result());
+  VisitForTest(expr->result_done());
+  Node* condition = environment()->Pop();
+  for_loop.BreakWhen(condition);
+  VisitForValue(expr->result_value());

[Michael Starzinger, 2015/02/16 19:58:58]

I am not sure how this is supposed to work in the end. But if I understand
correctly then the operand stack size in full-codegen is not statically known
within the loop, because each iteration over the loop pushes one element in the
operand stack.

In TurboFan (as well as in Crankshaft for that matter) the environment is a
static simulation of the operand stack (similar to an abstract interpretation).
But here the operand stack cannot be simulated.

[caitp (gmail), 2015/02/16 21:41:51]

I don't think I ever finished the AstGraphBuilder portion, so I wouldn't pay
much attention to it, it probably doesn't make sense.

for now, maybe it makes more sense to just desugar spread calls into
Function.apply() as suggested previously.

+  for_loop.EndBody();
+  for_loop.EndLoop();
+}
+
+
 void AstGraphBuilder::VisitThisFunction(ThisFunction* expr) {
   Node* value = GetFunctionClosure();
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitSuperReference(SuperReference* expr) {
   // TODO(turbofan): Implement super here.
   SetStackOverflow();
   ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
@@ skipping 893 matching lines @@
     Node* dead_node = graph()->NewNode(common()->Dead());
     dead_control_.set(dead_node);
     return dead_node;
   }
   return dead_control_.get();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8