Fix bug with re-scoping arrow function parameter initializers

src/parsing/parameter-initializer-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/parsing/parameter-initializer-rewriter.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 37 matching lines @@
                   const std::pair<Variable*, int>& right) {
     return left.second < right.second;
   }
 };
 
 Rewriter::~Rewriter() {
   if (!temps_.empty()) {
     // Ensure that we add temporaries in the order they appeared in old_scope_.
     std::sort(temps_.begin(), temps_.end(), LessThanSecond());
     for (auto var_and_index : temps_) {
-      var_and_index.first->set_scope(new_scope_);
-      new_scope_->AddTemporary(var_and_index.first);
+      Scope* scope = new_scope_->ClosureScope();
+      var_and_index.first->set_scope(scope);
+      scope->AddTemporary(var_and_index.first);
     }
   }
 }
 
 void Rewriter::VisitFunctionLiteral(FunctionLiteral* function_literal) {
   function_literal->scope()->ReplaceOuterScope(new_scope_);
 }
 
 
 void Rewriter::VisitClassLiteral(ClassLiteral* class_literal) {
@@ skipping 13 matching lines @@
     // the class scope on their scope chain.
     DCHECK(prop->value()->IsFunctionLiteral());
   }
 }
 
 
 void Rewriter::VisitVariableProxy(VariableProxy* proxy) {
   if (proxy->is_resolved()) {
     Variable* var = proxy->var();
     if (var->mode() != TEMPORARY) return;
-    // For rewriting inside the same ClosureScope (e.g., putting default
-    // parameter values in their own inner scope in certain cases), refrain
-    // from invalidly moving temporaries to a block scope.
-    if (var->scope()->ClosureScope() == new_scope_->ClosureScope()) return;
-    int index = old_scope_->RemoveTemporary(var);
+    // Temporaries are only placed in ClosureScopes.
+    DCHECK_EQ(var->scope(), var->scope()->ClosureScope());
+    // If the temporary is already where it should be, return quickly.
+    if (var->scope() == new_scope_->ClosureScope()) return;
+    int index = old_scope_->ClosureScope()->RemoveTemporary(var);

[adamk, 2016/06/27 18:49:31]

What if the rewriter computed the ClosureScopes of both the old and new scopes
during construction? It's a scope chain walk every time otherwise...

[nickie, 2016/06/28 09:26:37]

Done.

     if (index >= 0) {
       temps_.push_back(std::make_pair(var, index));
     }
   } else if (old_scope_->RemoveUnresolved(proxy)) {
     new_scope_->AddUnresolved(proxy);
   }
 }
 
 
 void Rewriter::VisitBlock(Block* stmt) {
@@ skipping 22 matching lines @@
 void RewriteParameterInitializerScope(uintptr_t stack_limit,
                                       Expression* initializer, Scope* old_scope,
                                       Scope* new_scope) {
   Rewriter rewriter(stack_limit, initializer, old_scope, new_scope);
   rewriter.Run();
 }
 
 
 }  // namespace internal
 }  // namespace v8