WIP: Implement ES6 Spread-calls

src/ast.h

 // 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.
 
 #ifndef V8_AST_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 75 matching lines @@
   V(Yield)                      \
   V(Throw)                      \
   V(Property)                   \
   V(Call)                       \
   V(CallNew)                    \
   V(CallRuntime)                \
   V(UnaryOperation)             \
   V(CountOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
+  V(SpreadOperation)            \
   V(ThisFunction)               \
   V(SuperReference)             \
   V(CaseClause)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   MODULE_NODE_LIST(V)                           \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
@@ skipping 15 matching lines @@
 class RegExpBackReference;
 class RegExpCapture;
 class RegExpCharacterClass;
 class RegExpCompiler;
 class RegExpDisjunction;
 class RegExpEmpty;
 class RegExpLookahead;
 class RegExpQuantifier;
 class RegExpText;
 
+// Other forward declarations
+class Scope;
+
 #define DEF_FORWARD_DECLARATION(type) class type;
 AST_NODE_LIST(DEF_FORWARD_DECLARATION)
 #undef DEF_FORWARD_DECLARATION
 
 
 // Typedef only introduced to avoid unreadable code.
 // Please do appreciate the required space in "> >".
 typedef ZoneList<Handle<String> > ZoneStringList;
 typedef ZoneList<Handle<Object> > ZoneObjectList;
 
@@ skipping 1743 matching lines @@
   // Helpers to determine how to handle the call.
   CallType GetCallType(Isolate* isolate) const;
   bool IsUsingCallFeedbackSlot(Isolate* isolate) const;
   bool IsUsingCallFeedbackICSlot(Isolate* isolate) const;
 
 #ifdef DEBUG
   // Used to assert that the FullCodeGenerator records the return site.
   bool return_is_recorded_;
 #endif
 
+  static bool HasSpreadArguments(ZoneList<Expression*>* arguments) {
+    ZoneList<Expression*>::iterator it;
+    for (it = arguments->begin(); it != arguments->end(); ++it) {
+      if ((*it)->IsSpreadOperation()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  inline bool HasSpreadArguments() const {
+    return HasSpreadArgumentsField::decode(bit_field_);
+  }
+
  protected:
   Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
        int pos)
       : Expression(zone, pos),
         ic_slot_or_slot_(FeedbackVectorICSlot::Invalid().ToInt()),
         expression_(expression),
         arguments_(arguments),
-        bit_field_(IsUninitializedField::encode(false)) {
+        bit_field_(
+            IsUninitializedField::encode(false) |
+            HasSpreadArgumentsField::encode(HasSpreadArguments(arguments))) {

[arv (Not doing code reviews), 2015/02/12 21:41:34]

Maybe have the parser keep track of this and set the flag instead?

     if (expression->IsProperty()) {
       expression->AsProperty()->mark_for_call();
     }
   }
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   // We store this as an integer because we don't know if we have a slot or
   // an ic slot until scoping time.
   int ic_slot_or_slot_;
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   Handle<JSFunction> target_;
   Handle<Cell> cell_;
   Handle<AllocationSite> allocation_site_;
   class IsUninitializedField : public BitField8<bool, 0, 1> {};
+  class HasSpreadArgumentsField : public BitField8<bool, 1, 1> {};
   uint8_t bit_field_;
 };
 
 
 class CallNew FINAL : public Expression {
  public:
   DECLARE_NODE_TYPE(CallNew)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
@@ skipping 306 matching lines @@
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Token::Value op_;
   Expression* left_;
   Expression* right_;
 
   Type* combined_type_;
 };
 
 
+class SpreadOperation FINAL : public Expression {
+ public:
+  DECLARE_NODE_TYPE(SpreadOperation)
+
+  Expression* expression() const { return expression_; }
+  Expression* assign_iterator() const { return assign_iterator_; }
+  Expression* next_result() const { return next_result_; }
+  Expression* result_done() const { return result_done_; }
+  Expression* result_value() const { return result_value_; }
+
+  static int num_ids() { return parent_num_ids(); }
+
+ protected:
+  SpreadOperation(Zone* zone, AstNodeFactory* factory,
+                  AstValueFactory* value_factory, Scope* scope,
+                  Expression* expression, int pos);
+  static int parent_num_ids() { return Expression::num_ids(); }
+
+ private:
+  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+  Expression* expression_;
+  Expression* assign_iterator_;
+  Expression* next_result_;
+  Expression* result_done_;
+  Expression* result_value_;
+};
+
+
 class Conditional FINAL : public Expression {
  public:
   DECLARE_NODE_TYPE(Conditional)
 
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
   Expression* else_expression() const { return else_expression_; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ThenId() const { return BailoutId(local_id(0)); }
@@ skipping 1200 matching lines @@
     return new (zone_) CountOperation(zone_, op, is_prefix, expr, pos);
   }
 
   CompareOperation* NewCompareOperation(Token::Value op,
                                         Expression* left,
                                         Expression* right,
                                         int pos) {
     return new (zone_) CompareOperation(zone_, op, left, right, pos);
   }
 
+  SpreadOperation* NewSpreadOperation(Scope* scope, Expression* expression,
+                                      int pos) {
+    return new (zone_) SpreadOperation(zone_, this, ast_value_factory_, scope,
+                                       expression, pos);
+  }
+
   Conditional* NewConditional(Expression* condition,
                               Expression* then_expression,
                               Expression* else_expression,
                               int position) {
     return new (zone_) Conditional(zone_, condition, then_expression,
                                    else_expression, position);
   }
 
   Assignment* NewAssignment(Token::Value op,
                             Expression* target,
@@ skipping 55 matching lines @@
   }
 
   ThisFunction* NewThisFunction(int pos) {
     return new (zone_) ThisFunction(zone_, pos);
   }
 
   SuperReference* NewSuperReference(VariableProxy* this_var, int pos) {
     return new (zone_) SuperReference(zone_, this_var, pos);
   }
 
+  // Utilities
+  Expression* GetIterator(Expression* iterable) {
+    Expression* iterator_symbol_literal =
+        NewSymbolLiteral("iterator_symbol", RelocInfo::kNoPosition);
+    int pos = iterable->position();
+    Expression* prop = NewProperty(iterable, iterator_symbol_literal, pos);
+    ZoneList<Expression*>* args = new (zone_) ZoneList<Expression*>(0, zone_);
+    return NewCall(prop, args, pos);
+  }
+
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_