Reapply "Resolve references to "this" the same way as normal variables""

src/runtime/runtime-debug.cc

 // Copyright 2014 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/accessors.h"
 #include "src/arguments.h"
 #include "src/compiler.h"
 #include "src/debug.h"
@@ skipping 841 matching lines @@
 static bool ParameterIsShadowedByContextLocal(Handle<ScopeInfo> info,
                                               Handle<String> parameter_name) {
   VariableMode mode;
   InitializationFlag init_flag;
   MaybeAssignedFlag maybe_assigned_flag;
   return ScopeInfo::ContextSlotIndex(info, parameter_name, &mode, &init_flag,
                                      &maybe_assigned_flag) != -1;
 }
 
 
+MUST_USE_RESULT
+static MaybeHandle<Context> MaterializeReceiver(
+    Isolate* isolate, Handle<Context> target, Handle<JSFunction> function,
+    JavaScriptFrame* frame) {
+  Handle<SharedFunctionInfo> shared(function->shared());
+  Handle<ScopeInfo> scope_info(shared->scope_info());
+  Handle<Object> receiver;
+  switch (scope_info->scope_type()) {
+  case FUNCTION_SCOPE: {
+    VariableMode variable_mode;
+    InitializationFlag init_flag;
+    MaybeAssignedFlag maybe_assigned_flag;
+
+    // Don't bother creating a fake context node if "this" is in the context
+    // already.
+    if (ScopeInfo::ContextSlotIndex(scope_info,
+            isolate->factory()->this_string(), &variable_mode, &init_flag,
+            &maybe_assigned_flag) >= 0) {
+      return target;
+    }
+    receiver = Handle<Object>(frame->receiver(), isolate);
+    break;
+  }
+  case MODULE_SCOPE:
+    receiver = isolate->factory()->undefined_value();
+    break;
+  case SCRIPT_SCOPE:
+    receiver = Handle<Object>(function->global_proxy(), isolate);
+    break;
+  default:
+    // For eval code, arrow functions, and the like, there's no "this" binding
+    // to materialize.
+    return target;
+  }
+
+  return isolate->factory()->NewCatchContext(function, target,
+      isolate->factory()->this_string(), receiver);
+}
+
+
 // Create a plain JSObject which materializes the local scope for the specified
 // frame.
 MUST_USE_RESULT
 static MaybeHandle<JSObject> MaterializeStackLocalsWithFrameInspector(
     Isolate* isolate, Handle<JSObject> target, Handle<ScopeInfo> scope_info,
     FrameInspector* frame_inspector) {
   // First fill all parameters.
   for (int i = 0; i < scope_info->ParameterCount(); ++i) {
     // Do not materialize the parameter if it is shadowed by a context local.
     Handle<String> name(scope_info->ParameterName(i));
@@ skipping 596 matching lines @@
   // Move to the next scope.
   void Next() {
     DCHECK(!failed_);
     ScopeType scope_type = Type();
     if (scope_type == ScopeTypeGlobal) {
       // The global scope is always the last in the chain.
       DCHECK(context_->IsNativeContext());
       context_ = Handle<Context>();
       return;
     }
-    if (scope_type == ScopeTypeScript) seen_script_scope_ = true;
-    if (nested_scope_chain_.is_empty()) {
-      if (scope_type == ScopeTypeScript) {
-        if (context_->IsScriptContext()) {
-          context_ = Handle<Context>(context_->previous(), isolate_);
-        }
-        CHECK(context_->IsNativeContext());
-      } else {
+    if (scope_type == ScopeTypeScript) {
+      seen_script_scope_ = true;
+      if (context_->IsScriptContext()) {
         context_ = Handle<Context>(context_->previous(), isolate_);
       }
+      if (!nested_scope_chain_.is_empty()) {
+        DCHECK_EQ(nested_scope_chain_.last()->scope_type(), SCRIPT_SCOPE);
+        nested_scope_chain_.RemoveLast();
+        DCHECK(nested_scope_chain_.is_empty());
+      }
+      CHECK(context_->IsNativeContext());
+      return;
+    }
+    if (nested_scope_chain_.is_empty()) {
+      context_ = Handle<Context>(context_->previous(), isolate_);
     } else {
       if (nested_scope_chain_.last()->HasContext()) {
         DCHECK(context_->previous() != NULL);
         context_ = Handle<Context>(context_->previous(), isolate_);
       }
       nested_scope_chain_.RemoveLast();
     }
   }
 
   // Return the type of the current scope.
@@ skipping 948 matching lines @@
       : isolate_(isolate),
         frame_(frame),
         inlined_jsframe_index_(inlined_jsframe_index) {
     FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
     Handle<JSFunction> function =
         handle(JSFunction::cast(frame_inspector.GetFunction()));
     Handle<Context> outer_context = handle(function->context(), isolate);
     outer_info_ = handle(function->shared());
     Handle<Context> inner_context;
 
+    // The "this" binding, if any, can't be bound via "with".  If we need to,
+    // add another node onto the outer context to bind "this".
+    if (!MaterializeReceiver(isolate, outer_context, function, frame)
+             .ToHandle(&outer_context))
+      return;
+
     bool stop = false;
     for (ScopeIterator it(isolate, frame, inlined_jsframe_index);
          !it.Failed() && !it.Done() && !stop; it.Next()) {
       ScopeIterator::ScopeType scope_type = it.Type();
 
       if (scope_type == ScopeIterator::ScopeTypeLocal) {
         Handle<JSObject> materialized_function =
             NewJSObjectWithNullProto(isolate);
 
         if (!MaterializeStackLocalsWithFrameInspector(
@@ skipping 691 matching lines @@
   return Smi::FromInt(isolate->debug()->is_active());
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugBreakInOptimizedCode) {
   UNIMPLEMENTED();
   return NULL;
 }
 }
 }  // namespace v8::internal