[destructuring] don't attempt to visit contents of FunctionLiterals

src/parsing/parser.cc

 // 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.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 4367 matching lines @@
       RelocInfo::kNoPosition);
   IfStatement* if_statement = factory()->NewIfStatement(
       condition, factory()->NewExpressionStatement(throw_type_error,
                                                    RelocInfo::kNoPosition),
       factory()->NewEmptyStatement(RelocInfo::kNoPosition),
       RelocInfo::kNoPosition);
   return if_statement;
 }
 
 
 class InitializerRewriter : public AstExpressionVisitor {

[adamk, 2016/04/05 17:54:30]

It seems like a more minimal fix for the problem at hand would be to override
VisitFunctionLiteral in this class, especially since the fact that this rewriter
shouldn't descend into function bodies (even if eagerly parsed) is specific to
it.

[caitp (gmail), 2016/04/05 18:02:05]

involves a lot more actual changes to do it that way (making the Visit##Type
methods protected instead of private, etc).

If that's preferred, will do

[adamk, 2016/04/05 18:06:26]

You shouldn't need to touch the base class at all: overriding private methods
works fine in C++. All you should need is:

void VisitFunctionLiteral(FunctionLiteral* expr) override { }

(since a FunctionLiteral is never a RewritableExpression)

[caitp (gmail), 2016/04/05 18:13:23]

Done.

  public:
   InitializerRewriter(uintptr_t stack_limit, Expression* root, Parser* parser,
                       Scope* scope)
-      : AstExpressionVisitor(stack_limit, root),
+      : AstExpressionVisitor(stack_limit, root, AstExpressionVisitor::Shallow),
         parser_(parser),
         scope_(scope) {}
 
  private:
   void VisitExpression(Expression* expr) {
     RewritableExpression* to_rewrite = expr->AsRewritableExpression();
     if (to_rewrite == nullptr || to_rewrite->is_rewritten()) return;
 
     Parser::PatternRewriter::RewriteDestructuringAssignment(parser_, to_rewrite,
                                                             scope_);
@@ skipping 2462 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8