[es6] implement spread calls

src/parser.cc

Index: src/parser.cc
diff --git a/src/parser.cc b/src/parser.cc
index 08941f501f333511f612603e597e627327fc9373..1808d74bae7d45d15cc12038e0f0c0f3e90b0b6c 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -815,6 +815,7 @@ Parser::Parser(CompilationInfo* info, uintptr_t stack_limit, uint32_t hash_seed,
   set_allow_harmony_computed_property_names(
       FLAG_harmony_computed_property_names);
   set_allow_harmony_rest_params(FLAG_harmony_rest_parameters);
+  set_allow_harmony_spreadcalls(FLAG_harmony_spreadcalls);
   set_allow_strong_mode(FLAG_strong_mode);
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
@@ -4043,6 +4044,8 @@ PreParser::PreParseResult Parser::ParseLazyFunctionBodyWithPreParser(
         allow_harmony_computed_property_names());
     reusable_preparser_->set_allow_harmony_rest_params(
         allow_harmony_rest_params());
+    reusable_preparser_->set_allow_harmony_spreadcalls(
+        allow_harmony_spreadcalls());
     reusable_preparser_->set_allow_strong_mode(allow_strong_mode());
   }
   PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
@@ -4154,7 +4157,8 @@ Expression* Parser::ParseV8Intrinsic(bool* ok) {
   Expect(Token::MOD, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
   const AstRawString* name = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
-  ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
+  Scanner::Location spread_pos;
+  ZoneList<Expression*>* args = ParseArguments(&spread_pos, CHECK_OK);
 
   if (extension_ != NULL) {
     // The extension structures are only accessible while parsing the
@@ -5474,4 +5478,49 @@ uint32_t Parser::ComputeTemplateLiteralHash(const TemplateLiteral* lit) {
 
   return running_hash;
 }
+
+
+ZoneList<v8::internal::Expression*>* Parser::PrepareSpreadCallArguments(
+    Expression* function, ZoneList<v8::internal::Expression*>* list) {
+  int length = list->length() + 3;

[arv (Not doing code reviews), 2015/02/18 15:07:06]

Please add a comment explaining "3 is the magic number".

+  Expression* thisArg;
+
+  if (function->IsProperty()) {

[arv (Not doing code reviews), 2015/02/18 15:07:06]

TODO: IsSuperReference

+    thisArg = function->AsProperty()->obj();
+  } else {
+    thisArg = factory()->NewUndefinedLiteral(RelocInfo::kNoPosition);
+  }
+  list->InsertAt(0, function, zone());
+  list->InsertAt(1, thisArg, zone());
+  list->InsertAt(2, factory()->NewSmiLiteral(length, RelocInfo::kNoPosition),
+                 zone());
+
+  for (int i = 3; i < length; ++i) {
+    Expression* arg = list->at(i);
+    if (arg->IsSpreadOperation()) {
+      list->Add(factory()->NewSmiLiteral(i, RelocInfo::kNoPosition), zone());

[arv (Not doing code reviews), 2015/02/18 15:07:06]

It is not clear to me what the list contains? I think we are storing the indexes
of the position of the spread expressions?

Maybe add a comment explaining what this looks like?

[caitp (gmail), 2015/02/18 15:32:08]

I tried to draw a graph of it in a comment, but it didn't add much clarity. For
reference though, it's sort of like this:

0. The function
1. The receiver
2. The index, in the list, of the index of the first spread expression (this is
where it gets confusing!)
3...N Each parameter expression passed to the call
N...M Index of each spread expression in the arguments list.

It's organized this way so that there isn't a bunch of extra array allocations
(arrays make it a bit more complicated for the preparser)

[arv (Not doing code reviews), 2015/02/18 15:36:54]

I think this is a really good solution but it is not obvious what is going on
here.

(I might borrow this approach for traceur)

+    }
+  }
+
+  return list;
+}
+
+
+ZoneList<v8::internal::Expression*>* Parser::PrepareSpreadCallNewArguments(
+    Expression* function, ZoneList<v8::internal::Expression*>* list) {
+  int length = list->length() + 2;
+
+  list->InsertAt(0, function, zone());
+  list->InsertAt(1, factory()->NewSmiLiteral(length, RelocInfo::kNoPosition),
+                 zone());
+
+  for (int i = 2; i < length; ++i) {
+    Expression* arg = list->at(i);
+    if (arg->IsSpreadOperation()) {
+      list->Add(factory()->NewSmiLiteral(i, RelocInfo::kNoPosition), zone());
+    }
+  }
+
+  return list;
+}
 } }  // namespace v8::internal