Rescope arrow-function parameter lists by moving the delta to the parameter scope

src/ast/scopes.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/ast/scopes.h"
 
 #include "src/accessors.h"
 #include "src/ast/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
@@ skipping 348 matching lines @@
     }
     outer_scope()->unresolved_ = unresolved_;
     unresolved_ = nullptr;
   }
 
   PropagateUsageFlagsToScope(outer_scope_);
 
   return NULL;
 }
 
+void Scope::Snapshot::Reparent(Scope* new_parent) const {
+  DCHECK_EQ(new_parent, outer_scope_->inner_scope_);
+  DCHECK_EQ(new_parent->outer_scope_, outer_scope_);
+  DCHECK_EQ(new_parent, new_parent->ClosureScope());
+  Scope* inner_scope = new_parent->sibling_;
+  if (inner_scope != top_inner_scope_) {
+    for (; inner_scope->sibling() != top_inner_scope_;
+         inner_scope = inner_scope->sibling()) {
+      inner_scope->outer_scope_ = new_parent;
+      DCHECK_NE(inner_scope, new_parent);
+    }
+    inner_scope->outer_scope_ = new_parent;
+
+    new_parent->inner_scope_ = new_parent->sibling_;

[nickie, 2016/07/21 15:08:52]

As you're blindly assigning here, I'd recommend to DCHECK that the new_parent
doesn't have any inner scopes already.

+    inner_scope->sibling_ = nullptr;
+    // Reset the sibling rather than the inner_scope_ since we
+    // want to keep new_parent there.
+    DCHECK_EQ(new_parent, outer_scope_->inner_scope_);
+    new_parent->sibling_ = top_inner_scope_;
+  }
+
+  if (outer_scope_->unresolved_ != top_unresolved_) {
+    VariableProxy* last;
+    for (last = outer_scope_->unresolved_;
+         last->next_unresolved() != top_unresolved_;
+         last = last->next_unresolved()) {
+    }
+    last->set_next_unresolved(nullptr);
+    new_parent->unresolved_ = outer_scope_->unresolved_;
+    outer_scope_->unresolved_ = top_unresolved_;
+  }
+
+  if (outer_scope_->ClosureScope()->temps_.length() != top_temp_) {
+    ZoneList<Variable*>* temps = &outer_scope_->ClosureScope()->temps_;
+    for (int i = top_temp_; i < temps->length(); i++) {
+      Variable* temp = (*temps)[i];
+      DCHECK_EQ(temp->scope(), temp->scope()->ClosureScope());
+      DCHECK_NE(temp->scope(), new_parent);
+      temp->set_scope(new_parent);
+      new_parent->AddTemporary(temp);
+    }
+    temps->Rewind(top_temp_);
+  }
+}
 
 void Scope::ReplaceOuterScope(Scope* outer) {
   DCHECK_NOT_NULL(outer);
   DCHECK_NOT_NULL(outer_scope_);
   DCHECK(!already_resolved());
   DCHECK(!outer->already_resolved());
   DCHECK(!outer_scope_->already_resolved());
   outer_scope_->RemoveInnerScope(this);
   outer->AddInnerScope(this);
   outer_scope_ = outer;
@@ skipping 1166 matching lines @@
       function_ != NULL && function_->proxy()->var()->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8