[es6] implement destructuring assignment

src/ast-expression-visitor.cc

 // Copyright 2015 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/ast-expression-visitor.h"
 
 #include "src/ast.h"
 #include "src/codegen.h"
@@ skipping 14 matching lines @@
 #define RECURSE_EXPRESSION(call)    \
   do {                              \
     DCHECK(!HasStackOverflow());    \
     ++depth_;                       \
     call;                           \
     --depth_;                       \
     if (HasStackOverflow()) return; \
   } while (false)
 
 
+#define RECURSE_EXPRESSION_RETURN_IF_VISIT_NODE(call) \
+  do {                                                \
+    AstNode* node = call;                             \
+    if (node) {                                       \
+      RECURSE_EXPRESSION(Visit(node));                \
+      return;                                         \
+    }                                                 \
+  } while (false)
+
+
 AstExpressionVisitor::AstExpressionVisitor(Isolate* isolate, Expression* root)
     : root_(root), depth_(0) {
   InitializeAstVisitor(isolate);
 }
 
 
 AstExpressionVisitor::AstExpressionVisitor(uintptr_t stack_limit,
                                            Expression* root)
     : root_(root), depth_(0) {
   InitializeAstVisitor(stack_limit);
@@ skipping 203 matching lines @@
   VisitExpression(expr);
   ZoneList<Expression*>* values = expr->values();
   for (int i = 0; i < values->length(); ++i) {
     Expression* value = values->at(i);
     RECURSE_EXPRESSION(Visit(value));
   }
 }
 
 
 void AstExpressionVisitor::VisitAssignment(Assignment* expr) {
+  RETURN_IF_VISIT_NODE(expr->destructuring_assignment());
   VisitExpression(expr);
+  RECURSE_EXPRESSION_RETURN_IF_VISIT_NODE(expr->destructuring_assignment());

[adamk, 2015/11/25 21:05:28]

Is this needed because VisitExpression could mutate |expr|?

[caitp (gmail), 2015/11/25 21:41:51]

I suppose it can, the InitializerRewriter  visitor does that, I think. AFAIK the
top-most RETURN_IF_VISIT_NODE probably should be removed, but I'm not positive

   RECURSE_EXPRESSION(Visit(expr->target()));
   RECURSE_EXPRESSION(Visit(expr->value()));
 }
 
 
 void AstExpressionVisitor::VisitYield(Yield* expr) {
   VisitExpression(expr);
   RECURSE_EXPRESSION(Visit(expr->generator_object()));
   RECURSE_EXPRESSION(Visit(expr->expression()));
 }
@@ skipping 120 matching lines @@
 void AstExpressionVisitor::VisitSuperCallReference(SuperCallReference* expr) {
   VisitExpression(expr);
   RECURSE_EXPRESSION(VisitVariableProxy(expr->this_var()));
   RECURSE_EXPRESSION(VisitVariableProxy(expr->new_target_var()));
   RECURSE_EXPRESSION(VisitVariableProxy(expr->this_function_var()));
 }
 
 
 }  // namespace internal
 }  // namespace v8