[es6] Re-implement rest parameters via desugaring.

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/assembler.h"
 #include "src/ast-value-factory.h"
 #include "src/bailout-reason.h"
@@ skipping 71 matching lines @@
   V(CallRuntime)                \
   V(UnaryOperation)             \
   V(CountOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
   V(Spread)                     \
   V(ThisFunction)               \
   V(SuperPropertyReference)     \
   V(SuperCallReference)         \
   V(CaseClause)                 \
-  V(EmptyParentheses)
+  V(EmptyParentheses)           \
+  V(RestParameter)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstNodeFactory;
 class AstVisitor;
 class Declaration;
@@ skipping 1620 matching lines @@
     const AstRawString* raw_name_;  // if !is_resolved_
     Variable* var_;                 // if is_resolved_
   };
   // Position is stored in the AstNode superclass, but VariableProxy needs to
   // know its end position too (for error messages). It cannot be inferred from
   // the variable name length because it can contain escapes.
   int end_position_;
 };
 
 
+class RestParameter final : public Expression {
+ public:
+  DECLARE_NODE_TYPE(RestParameter)
+
+  VariableProxy* parameter() const { return parameter_; }
+  int literal_index() const { return literal_index_; }
+
+  int end_position() const { return parameter_->end_position(); }
+
+ protected:
+  RestParameter(Zone* zone, VariableProxy* parameter, int literal_index,
+                int position)
+      : Expression(zone, position),
+        parameter_(parameter),
+        literal_index_(literal_index) {}
+
+  VariableProxy* parameter_;
+  int literal_index_;
+
+  friend class AstLiteralReindexer;
+};
+
+
 // Left-hand side can only be a property, a global or a (parameter or local)
 // slot.
 enum LhsKind {
   VARIABLE,
   NAMED_PROPERTY,
   KEYED_PROPERTY,
   NAMED_SUPER_PROPERTY,
   KEYED_SUPER_PROPERTY
 };
 
@@ skipping 1749 matching lines @@
 
   VariableProxy* NewVariableProxy(const AstRawString* name,
                                   Variable::Kind variable_kind,
                                   int start_position = RelocInfo::kNoPosition,
                                   int end_position = RelocInfo::kNoPosition) {
     DCHECK_NOT_NULL(name);
     return new (zone_)
         VariableProxy(zone_, name, variable_kind, start_position, end_position);
   }
 
+  RestParameter* NewRestParameter(VariableProxy* parameter, int literal_index,
+                                  int position) {
+    DCHECK_NOT_NULL(parameter);
+    DCHECK(literal_index >= 0);
+    DCHECK(position >= 0);
+
+    return new (zone_) RestParameter(zone_, parameter, literal_index, position);
+  }
+
   Property* NewProperty(Expression* obj, Expression* key, int pos) {
     return new (zone_) Property(zone_, obj, key, pos);
   }
 
   Call* NewCall(Expression* expression,
                 ZoneList<Expression*>* arguments,
                 int pos) {
     return new (zone_) Call(zone_, expression, arguments, pos);
   }
 
@@ skipping 142 matching lines @@
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_