[destructuring] Implement spread binding patterns.

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 2186 matching lines @@
   Type* combined_type_;
 };
 
 
 class Spread final : public Expression {
  public:
   DECLARE_NODE_TYPE(Spread)
 
   Expression* expression() const { return expression_; }
 
+  int literal_index() const {
+    DCHECK(literal_index_ >= 0);
+    return literal_index_;
+  }
+
   static int num_ids() { return parent_num_ids(); }
 
  protected:
-  Spread(Zone* zone, Expression* expression, int pos)
-      : Expression(zone, pos), expression_(expression) {}
+  Spread(Zone* zone, Expression* expression, int literal_index, int pos)
+      : Expression(zone, pos),
+        literal_index_(literal_index),
+        expression_(expression) {}
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
+  // Literal index is only used when Spread is renterpreted as a pattern.

[rossberg, 2015/05/20 12:57:35]

Nit: typo

[Dmitry Lomov (no reviews), 2015/05/20 14:22:02]

Undid this change.

+  int literal_index_;
+
   Expression* expression_;
 };
 
 
 class Conditional final : public Expression {
  public:
   DECLARE_NODE_TYPE(Conditional)
 
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
@@ skipping 1190 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);
   }
 
-  Spread* NewSpread(Expression* expression, int pos) {
-    return new (zone_) Spread(zone_, expression, pos);
+  Spread* NewSpread(Expression* expression, int literal_index, int pos) {
+    return new (zone_) Spread(zone_, expression, literal_index, pos);
   }
 
   Conditional* NewConditional(Expression* condition,
                               Expression* then_expression,
                               Expression* else_expression,
                               int position) {
     return new (zone_) Conditional(zone_, condition, then_expression,
                                    else_expression, position);
   }
 
@@ skipping 66 matching lines @@
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_