WIP: Implement ES6 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 718 matching lines @@
 Expression* ParserTraits::ExpressionFromString(int pos, Scanner* scanner,
                                                AstNodeFactory* factory) {
   const AstRawString* symbol = GetSymbol(scanner);
   if (parser_->fni_ != NULL) parser_->fni_->PushLiteralName(symbol);
   return factory->NewStringLiteral(symbol, pos);
 }
 
 
 Expression* ParserTraits::GetIterator(Expression* iterable,
                                       AstNodeFactory* factory) {
-  Expression* iterator_symbol_literal =
-      factory->NewSymbolLiteral("iterator_symbol", RelocInfo::kNoPosition);
-  int pos = iterable->position();
-  Expression* prop =
-      factory->NewProperty(iterable, iterator_symbol_literal, pos);
-  Zone* zone = parser_->zone();
-  ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(0, zone);
-  return factory->NewCall(prop, args, pos);
+  return factory->GetIterator(iterable);
 }
 
 
 Literal* ParserTraits::GetLiteralTheHole(int position,
                                          AstNodeFactory* factory) {
   return factory->NewTheHoleLiteral(RelocInfo::kNoPosition);
 }
 
 
 Expression* ParserTraits::ParseV8Intrinsic(bool* ok) {
@@ skipping 3359 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 (spread_pos.IsValid()) {
+    // Maybe support spread calls for intrinsics/runtime calls?
+    ParserTraits::ReportMessageAt(spread_pos, "spreadcall_intrinsic");
+    *ok = false;
+    return NULL;
+  }
 
   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 1282 matching lines @@
     } 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;
 }
 } }  // namespace v8::internal