[es6] implement destructuring assignment

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 57 matching lines @@
   V(FunctionLiteral)            \
   V(ClassLiteral)               \
   V(NativeFunctionLiteral)      \
   V(Conditional)                \
   V(VariableProxy)              \
   V(Literal)                    \
   V(RegExpLiteral)              \
   V(ObjectLiteral)              \
   V(ArrayLiteral)               \
   V(Assignment)                 \
+  V(AssignmentPattern)          \
   V(Yield)                      \
   V(Throw)                      \
   V(Property)                   \
   V(Call)                       \
   V(CallNew)                    \
   V(CallRuntime)                \
   V(UnaryOperation)             \
   V(CountOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
@@ skipping 2301 matching lines @@
   // Expression's trailing 16-bit field.
   uint16_t bit_field_;
   Expression* target_;
   Expression* value_;
   BinaryOperation* binary_operation_;
   SmallMapList receiver_types_;
   FeedbackVectorSlot slot_;
 };
 
 
+class AssignmentPattern final : public Expression {
+ public:
+  DECLARE_NODE_TYPE(AssignmentPattern)
+
+  // AssignmentPattern should always be the Target of an Assignment.
+  // If encountered during compilation, and the assignment expression
+  // is not null (the node has been rewritten), the rewritten expression
+  // should be used in place of the normal assignment behaviour.
+  // Otherwise, the LHS is treated as the original pattern, which should
+  // result in an exception.
+  bool is_rewritten() const { return expression_ != pattern_; }
+  Expression* pattern() const { return pattern_; }
+  Expression* expression() const { return expression_; }
+
+  static int num_ids() { return parent_num_ids(); }
+
+  void set_expression(Expression* expr) {
+    // Only to be called by Parser::PatternRewriter
+    DCHECK_NE(expr, pattern_);
+    DCHECK_NOT_NULL(expr);
+    expression_ = expr;
+  }
+
+ protected:
+  AssignmentPattern(Zone* zone, Expression* pattern, int pos)
+      : Expression(zone, pos), pattern_(pattern), expression_(pattern) {}
+  static int parent_num_ids() { return Expression::num_ids(); }
+
+ private:
+  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+  Expression* pattern_;
+  Expression* expression_;
+};
+
+
 class Yield final : public Expression {
  public:
   DECLARE_NODE_TYPE(Yield)
 
   enum Kind {
     kInitial,  // The initial yield that returns the unboxed generator object.
     kSuspend,  // A normal yield: { value: EXPRESSION, done: false }
     kDelegating,  // A yield*.
     kFinal        // A return: { value: EXPRESSION, done: true }
   };
@@ skipping 1141 matching lines @@
     Assignment* assign =
         new (local_zone_) Assignment(local_zone_, op, target, value, pos);
     if (assign->is_compound()) {
       DCHECK(Token::IsAssignmentOp(op));
       assign->binary_operation_ =
           NewBinaryOperation(assign->binary_op(), target, value, pos + 1);
     }
     return assign;
   }
 
+  AssignmentPattern* NewAssignmentPattern(Expression* pattern, int pos) {
+    DCHECK(pattern->IsObjectLiteral() || pattern->IsArrayLiteral());
+    return new (local_zone_) AssignmentPattern(local_zone_, pattern, pos);
+  }
+
   Yield* NewYield(Expression *generator_object,
                   Expression* expression,
                   Yield::Kind yield_kind,
                   int pos) {
     if (!expression) expression = NewUndefinedLiteral(pos);
     return new (local_zone_)
         Yield(local_zone_, generator_object, expression, yield_kind, pos);
   }
 
   Throw* NewThrow(Expression* exception, int pos) {
@@ skipping 90 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_H_