[es6] implement spread calls

src/parser.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/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 797 matching lines @@
   set_allow_harmony_arrow_functions(FLAG_harmony_arrow_functions);
   set_allow_harmony_numeric_literals(FLAG_harmony_numeric_literals);
   set_allow_harmony_classes(FLAG_harmony_classes);
   set_allow_harmony_object_literals(FLAG_harmony_object_literals);
   set_allow_harmony_templates(FLAG_harmony_templates);
   set_allow_harmony_sloppy(FLAG_harmony_sloppy);
   set_allow_harmony_unicode(FLAG_harmony_unicode);
   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) {
     use_counts_[feature] = 0;
   }
   if (info->ast_value_factory() == NULL) {
     // info takes ownership of AstValueFactory.
     info->SetAstValueFactory(new AstValueFactory(zone(), hash_seed));
     ast_value_factory_ = info->ast_value_factory();
   }
@@ skipping 3208 matching lines @@
     reusable_preparser_->set_allow_harmony_classes(allow_harmony_classes());
     reusable_preparser_->set_allow_harmony_object_literals(
         allow_harmony_object_literals());
     reusable_preparser_->set_allow_harmony_templates(allow_harmony_templates());
     reusable_preparser_->set_allow_harmony_sloppy(allow_harmony_sloppy());
     reusable_preparser_->set_allow_harmony_unicode(allow_harmony_unicode());
     reusable_preparser_->set_allow_harmony_computed_property_names(
         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(
       language_mode(), function_state_->kind(), logger);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
@@ skipping 91 matching lines @@
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
 
   int pos = peek_position();
   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
     // very first time not when reparsing because of lazy compilation.
     scope_->DeclarationScope()->ForceEagerCompilation();
   }
 
   const Runtime::Function* function = Runtime::FunctionForName(name->string());
 
   // Check for built-in IS_VAR macro.
@@ skipping 1299 matching lines @@
           running_hash, data, raw_string->length());
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   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