Fix bug with nested spreads as patterns

src/parsing/pattern-rewriter.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/ast/ast.h"
 #include "src/messages.h"
 #include "src/parsing/parameter-initializer-rewriter.h"
 #include "src/parsing/parser.h"
 
 namespace v8 {
@@ skipping 243 matching lines @@
         factory()->NewExpressionStatement(assignment, kNoSourcePosition),
         zone());
   }
   return temp;
 }
 
 
 void Parser::PatternRewriter::VisitRewritableExpression(
     RewritableExpression* node) {
   // If this is not a destructuring assignment...
-  if (!IsAssignmentContext() || !node->expression()->IsAssignment()) {
+  if (!IsAssignmentContext()) {
     // Mark the node as rewritten to prevent redundant rewriting, and
     // perform BindingPattern rewriting
     DCHECK(!node->is_rewritten());
     node->Rewrite(node->expression());
     return Visit(node->expression());
+  } else if (!node->expression()->IsAssignment()) {
+    return Visit(node->expression());

[caitp, 2016/09/01 15:34:41]

my understanding is, this will recursively continue the rewriting from the
Visit(node->expression()) 2 lines above this, right?

I think it looks okay, but I'm not sure why the nested pattern would be a
RewritableExpression in the first place

   }
 
   if (node->is_rewritten()) return;
   DCHECK(IsAssignmentContext());
   Assignment* assign = node->expression()->AsAssignment();
   DCHECK_NOT_NULL(assign);
   DCHECK_EQ(Token::ASSIGN, assign->op());
 
   auto initializer = assign->value();
   auto value = initializer;
@@ skipping 416 matching lines @@
 NOT_A_PATTERN(TryFinallyStatement)
 NOT_A_PATTERN(UnaryOperation)
 NOT_A_PATTERN(VariableDeclaration)
 NOT_A_PATTERN(WhileStatement)
 NOT_A_PATTERN(WithStatement)
 NOT_A_PATTERN(Yield)
 
 #undef NOT_A_PATTERN
 }  // namespace internal
 }  // namespace v8