WIP context-allocation for “this” in arrow functions

src/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/v8.h"
 
 #include "src/scopes.h"
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 591 matching lines @@
 
   // Collect internals which are always allocated on the heap.
   for (int i = 0; i < internals_.length(); i++) {
     Variable* var = internals_[i];
     if (var->is_used()) {
       DCHECK(var->IsContextSlot());
       context_locals->Add(var, zone());
     }
   }
 
+  // Arrow functions can cause the receiver to be copied in the context.
+  if (receiver_ && receiver_->has_forced_context_allocation()) {
+    DCHECK(receiver_->IsContextSlot());
+    context_locals->Add(receiver_, zone());
+  }
+
   // Collect temporaries which are always allocated on the stack, unless the
   // context as a whole has forced context allocation.
   for (int i = 0; i < temps_.length(); i++) {
     Variable* var = temps_[i];
     if (var->is_used()) {
       if (var->IsContextSlot()) {
         DCHECK(has_forced_context_allocation());
         context_locals->Add(var, zone());
       } else {
         DCHECK(var->IsStackLocal());
@@ skipping 549 matching lines @@
   }
 
   bool calls_sloppy_eval =
       this->calls_sloppy_eval() || outer_scope_calls_sloppy_eval_;
   for (int i = 0; i < inner_scopes_.length(); i++) {
     Scope* inner = inner_scopes_[i];
     inner->PropagateScopeInfo(calls_sloppy_eval);
     if (inner->scope_calls_eval_ || inner->inner_scope_calls_eval_) {
       inner_scope_calls_eval_ = true;
     }
+
     // If the inner scope is an arrow function, propagate the flags tracking
     // usage of arguments/super/this, but do not propagate them out from normal
     // functions.
-    if (!inner->is_function_scope() || inner->is_arrow_scope()) {
-      if (inner->scope_uses_arguments_ || inner->inner_scope_uses_arguments_) {
+    if (inner->is_arrow_scope()) {
+      if (inner->scope_uses_this_ || inner->inner_scope_uses_this_)
+        inner_scope_uses_this_ = true;
+      if (inner->scope_uses_arguments_ || inner->inner_scope_uses_arguments_)
         inner_scope_uses_arguments_ = true;
-      }
       if (inner->scope_uses_super_property_ ||
-          inner->inner_scope_uses_super_property_) {
+          inner->inner_scope_uses_super_property_)
         inner_scope_uses_super_property_ = true;
-      }
       if (inner->uses_super_constructor_call() ||
-          inner->inner_scope_uses_super_constructor_call_) {
+          inner->inner_scope_uses_super_constructor_call_)
         inner_scope_uses_super_constructor_call_ = true;
-      }
-      if (inner->scope_uses_this_ || inner->inner_scope_uses_this_) {
+    } else if (!inner->is_function_scope()) {
+      if (inner->scope_uses_this_)
+        scope_uses_this_ = true;
+      if (inner->scope_uses_arguments_)
+        scope_uses_arguments_ = true;
+      if (inner->scope_uses_super_property_)
+        scope_uses_super_property_ = true;
+      if (inner->scope_uses_super_constructor_call_)
+        scope_uses_super_constructor_call_ = true;
+      if (inner->inner_scope_uses_this_)
         inner_scope_uses_this_ = true;
-      }
+      if (inner->inner_scope_uses_arguments_)
+        inner_scope_uses_arguments_ = true;
+      if (inner->inner_scope_uses_super_property_)
+        inner_scope_uses_super_property_ = true;
+      if (inner->inner_scope_uses_super_constructor_call_)
+        inner_scope_uses_super_constructor_call_ = true;
     }
+
     if (inner->force_eager_compilation_) {
       force_eager_compilation_ = true;
     }
     if (asm_module_ && inner->scope_type() == FUNCTION_SCOPE) {
       inner->asm_function_ = true;
     }
   }
 }
 
 
@@ skipping 107 matching lines @@
           AllocateHeapSlot(var);
         }
       } else {
         DCHECK(var->IsUnallocated() || var->IsParameter());
         if (var->IsUnallocated()) {
           var->AllocateTo(Variable::PARAMETER, i);
         }
       }
     }
   }
+
+  // If the scope contains at least one inner arrow function which uses
+  // "this", the receiver must be copied to the context, from where it will
+  // be looked up by code emitted in the prologues of arrow functions.
+  if (inner_scope_uses_this_) {
+    DCHECK(receiver_);
+    if (receiver_->IsUnallocated() || !receiver_->IsContextSlot()) {
+      receiver_->ForceContextAllocation();
+      AllocateHeapSlot(receiver_);
+    }
+    DCHECK(MustAllocateInContext(receiver_));
+  }
 }
 
 
 void Scope::AllocateNonParameterLocal(Variable* var) {
   DCHECK(var->scope() == this);
   DCHECK(!var->IsVariable(isolate_->factory()->dot_result_string()) ||
          !var->IsStackLocal());
   if (var->IsUnallocated() && MustAllocate(var)) {
     if (MustAllocateInContext(var)) {
       AllocateHeapSlot(var);
@@ skipping 96 matching lines @@
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->proxy()->var()->IsContextSlot() ? 1 : 0);
 }
 
 } }  // namespace v8::internal