Revert of Debugger: use FrameInspector in ScopeIterator to find context.

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 511 matching lines @@
                          : frame_->LookupCode()->SourcePosition(frame_->pc());
   }
   bool IsConstructor() {
     return is_optimized_ && !is_bottommost_
                ? deoptimized_frame_->HasConstructStub()
                : frame_->IsConstructor();
   }
   Object* GetContext() {
     return is_optimized_ ? deoptimized_frame_->GetContext() : frame_->context();
   }
-  JavaScriptFrame* GetArgumentsFrame() { return frame_; }
 
   // To inspect all the provided arguments the frame might need to be
   // replaced with the arguments frame.
   void SetArgumentsFrame(JavaScriptFrame* frame) {
     DCHECK(has_adapted_arguments_);
     frame_ = frame;
     is_optimized_ = frame_->is_optimized();
     DCHECK(!is_optimized_);
   }
 
@@ skipping 410 matching lines @@
 
   MaterializeStackLocalsWithFrameInspector(isolate, target, scope_info,
                                            frame_inspector);
 }
 
 
 static void UpdateStackLocalsFromMaterializedObject(
     Isolate* isolate, Handle<JSObject> target, Handle<ScopeInfo> scope_info,
     JavaScriptFrame* frame, int inlined_jsframe_index) {
   if (inlined_jsframe_index != 0 || frame->is_optimized()) {
-    // Optimized frames are not supported. Simply give up.
+    // Optimized frames are not supported.
+    // TODO(yangguo): make sure all code deoptimized when debugger is active
+    //                and assert that this cannot happen.
     return;
   }
 
   // Parameters.
   for (int i = 0; i < scope_info->ParameterCount(); ++i) {
     // Shadowed parameters were not materialized.
     Handle<String> name(scope_info->ParameterName(i));
     if (ParameterIsShadowedByContextLocal(scope_info, name)) continue;
 
     DCHECK(!frame->GetParameter(i)->IsTheHole());
@@ skipping 12 matching lines @@
     Handle<Object> value = Object::GetPropertyOrElement(
                                target, handle(scope_info->StackLocalName(i),
                                               isolate)).ToHandleChecked();
     frame->SetExpression(index, *value);
   }
 }
 
 
 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalContext(
     Isolate* isolate, Handle<JSObject> target, Handle<JSFunction> function,
-    Handle<Context> frame_context) {
+    JavaScriptFrame* frame) {
   HandleScope scope(isolate);
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<ScopeInfo> scope_info(shared->scope_info());
 
   if (!scope_info->HasContext()) return target;
 
   // Third fill all context locals.
+  Handle<Context> frame_context(Context::cast(frame->context()));
   Handle<Context> function_context(frame_context->declaration_context());
   ScopeInfo::CopyContextLocalsToScopeObject(scope_info, function_context,
                                             target);
 
   // Finally copy any properties from the function context extension.
   // These will be variables introduced by eval.
   if (function_context->closure() == *function) {
     if (function_context->has_extension() &&
         !function_context->IsNativeContext()) {
       Handle<JSObject> ext(JSObject::cast(function_context->extension()));
@@ skipping 35 matching lines @@
         ScriptContextTable::GetContext(script_contexts, context_index);
     Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
     ScopeInfo::CopyContextLocalsToScopeObject(scope_info, context,
                                               script_scope);
   }
   return script_scope;
 }
 
 
 MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalScope(
-    Isolate* isolate, FrameInspector* frame_inspector) {
-  Handle<JSFunction> function(JSFunction::cast(frame_inspector->GetFunction()));
+    Isolate* isolate, JavaScriptFrame* frame, int inlined_jsframe_index) {
+  FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
+  Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
 
   Handle<JSObject> local_scope =
       isolate->factory()->NewJSObject(isolate->object_function());
   MaterializeStackLocalsWithFrameInspector(isolate, local_scope, function,
-                                           frame_inspector);
+                                           &frame_inspector);
 
-  Handle<Context> frame_context(Context::cast(frame_inspector->GetContext()));
-
-  return MaterializeLocalContext(isolate, local_scope, function, frame_context);
+  return MaterializeLocalContext(isolate, local_scope, function, frame);
 }
 
 
 // Set the context local variable value.
 static bool SetContextLocalValue(Isolate* isolate, Handle<ScopeInfo> scope_info,
                                  Handle<Context> context,
                                  Handle<String> variable_name,
                                  Handle<Object> new_value) {
   for (int i = 0; i < scope_info->ContextLocalCount(); i++) {
     Handle<String> next_name(scope_info->ContextLocalName(i));
     if (String::Equals(variable_name, next_name)) {
       VariableMode mode;
       VariableLocation location;
       InitializationFlag init_flag;
       MaybeAssignedFlag maybe_assigned_flag;
       int context_index =
           ScopeInfo::ContextSlotIndex(scope_info, next_name, &mode, &location,
                                       &init_flag, &maybe_assigned_flag);
       context->set(context_index, *new_value);
       return true;
     }
   }
 
   return false;
 }
 
 
 static bool SetLocalVariableValue(Isolate* isolate, JavaScriptFrame* frame,
+                                  int inlined_jsframe_index,
                                   Handle<String> variable_name,
                                   Handle<Object> new_value) {
-  // Optimized frames are not supported.
-  if (frame->is_optimized()) return false;
+  if (inlined_jsframe_index != 0 || frame->is_optimized()) {
+    // Optimized frames are not supported.
+    return false;
+  }
 
   Handle<JSFunction> function(frame->function());
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<ScopeInfo> scope_info(shared->scope_info());
 
   bool default_result = false;
 
   // Parameters.
   for (int i = 0; i < scope_info->ParameterCount(); ++i) {
     HandleScope scope(isolate);
@@ skipping 188 matching lines @@
   context->set(Context::THROWN_OBJECT_INDEX, *new_value);
   return true;
 }
 
 
 // Create a plain JSObject which materializes the block scope for the specified
 // block context.
 static Handle<JSObject> MaterializeBlockScope(Isolate* isolate,
                                               Handle<ScopeInfo> scope_info,
                                               Handle<Context> context,
-                                              FrameInspector* frame_inspector) {
+                                              JavaScriptFrame* frame,
+                                              int inlined_jsframe_index) {
   Handle<JSObject> block_scope =
       isolate->factory()->NewJSObject(isolate->object_function());
 
-  if (frame_inspector != nullptr) {
+  if (frame != nullptr) {
+    FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
     MaterializeStackLocalsWithFrameInspector(isolate, block_scope, scope_info,
-                                             frame_inspector);
+                                             &frame_inspector);
   }
 
   if (!context.is_null()) {
     Handle<ScopeInfo> scope_info_from_context(
         ScopeInfo::cast(context->extension()));
     // Fill all context locals.
     ScopeInfo::CopyContextLocalsToScopeObject(scope_info_from_context, context,
                                               block_scope);
   }
 
@@ skipping 30 matching lines @@
     ScopeTypeGlobal = 0,
     ScopeTypeLocal,
     ScopeTypeWith,
     ScopeTypeClosure,
     ScopeTypeCatch,
     ScopeTypeBlock,
     ScopeTypeScript,
     ScopeTypeModule
   };
 
-  ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
-                bool ignore_nested_scopes = false)
+  ScopeIterator(Isolate* isolate, JavaScriptFrame* frame,
+                int inlined_jsframe_index, bool ignore_nested_scopes = false)
       : isolate_(isolate),
-        frame_inspector_(frame_inspector),
-        context_(Context::cast(frame_inspector->GetContext())),
+        frame_(frame),
+        inlined_jsframe_index_(inlined_jsframe_index),
+        function_(frame->function()),
+        context_(Context::cast(frame->context())),
         nested_scope_chain_(4),
         seen_script_scope_(false),
         failed_(false) {
     // Catch the case when the debugger stops in an internal function.
-    Handle<SharedFunctionInfo> shared_info(function()->shared());
+    Handle<SharedFunctionInfo> shared_info(function_->shared());
     Handle<ScopeInfo> scope_info(shared_info->scope_info());
     if (shared_info->script() == isolate->heap()->undefined_value()) {
-      while (context_->closure() == function()) {
+      while (context_->closure() == *function_) {
         context_ = Handle<Context>(context_->previous(), isolate_);
       }
       return;
     }
 
     // Currently it takes too much time to find nested scopes due to script
     // parsing. Sometimes we want to run the ScopeIterator as fast as possible
     // (for example, while collecting async call stacks on every
     // addEventListener call), even if we drop some nested scopes.
     // Later we may optimize getting the nested scopes (cache the result?)
     // and include nested scopes into the "fast" iteration case as well.
 
     if (!ignore_nested_scopes && !shared_info->debug_info()->IsUndefined()) {
       // The source position at return is always the end of the function,
       // which is not consistent with the current scope chain. Therefore all
       // nested with, catch and block contexts are skipped, and we can only
       // inspect the function scope.
       // This can only happen if we set a break point inside right before the
       // return, which requires a debug info to be available.
       Handle<DebugInfo> debug_info = Debug::GetDebugInfo(shared_info);
 
       // PC points to the instruction after the current one, possibly a break
       // location as well. So the "- 1" to exclude it from the search.
-      Address call_pc = frame()->pc() - 1;
+      Address call_pc = frame->pc() - 1;
 
       // Find the break point where execution has stopped.
       BreakLocation location =
           BreakLocation::FromAddress(debug_info, ALL_BREAK_LOCATIONS, call_pc);
 
       ignore_nested_scopes = location.IsReturn();
     }
 
     if (ignore_nested_scopes) {
       if (scope_info->HasContext()) {
         context_ = Handle<Context>(context_->declaration_context(), isolate_);
       } else {
-        while (context_->closure() == function()) {
+        while (context_->closure() == *function_) {
           context_ = Handle<Context>(context_->previous(), isolate_);
         }
       }
       if (scope_info->scope_type() == FUNCTION_SCOPE ||
           scope_info->scope_type() == ARROW_SCOPE) {
         nested_scope_chain_.Add(scope_info);
       }
     } else {
       // Reparse the code and analyze the scopes.
       Handle<Script> script(Script::cast(shared_info->script()));
       Scope* scope = NULL;
 
       // Check whether we are in global, eval or function code.
       Handle<ScopeInfo> scope_info(shared_info->scope_info());
       Zone zone;
       if (scope_info->scope_type() != FUNCTION_SCOPE &&
           scope_info->scope_type() != ARROW_SCOPE) {
         // Global or eval code.
         ParseInfo info(&zone, script);
         if (scope_info->scope_type() == SCRIPT_SCOPE) {
           info.set_global();
         } else {
           DCHECK(scope_info->scope_type() == EVAL_SCOPE);
           info.set_eval();
-          info.set_context(Handle<Context>(function()->context()));
+          info.set_context(Handle<Context>(function_->context()));
         }
         if (Parser::ParseStatic(&info) && Scope::Analyze(&info)) {
           scope = info.function()->scope();
         }
         RetrieveScopeChain(scope, shared_info);
       } else {
         // Function code
-        ParseInfo info(&zone, Handle<JSFunction>(function()));
+        ParseInfo info(&zone, function_);
         if (Parser::ParseStatic(&info) && Scope::Analyze(&info)) {
           scope = info.function()->scope();
         }
         RetrieveScopeChain(scope, shared_info);
       }
     }
   }
 
   ScopeIterator(Isolate* isolate, Handle<JSFunction> function)
       : isolate_(isolate),
-        frame_inspector_(NULL),
+        frame_(NULL),
+        inlined_jsframe_index_(0),
+        function_(function),
         context_(function->context()),
         seen_script_scope_(false),
         failed_(false) {
-    if (function->IsBuiltin()) context_ = Handle<Context>();
+    if (function->IsBuiltin()) {
+      context_ = Handle<Context>();
+    }
   }
 
   // More scopes?
   bool Done() {
     DCHECK(!failed_);
     return context_.is_null();
   }
 
   bool Failed() { return failed_; }
 
@@ skipping 90 matching lines @@
     DCHECK(!failed_);
     switch (Type()) {
       case ScopeIterator::ScopeTypeGlobal:
         return Handle<JSObject>(CurrentContext()->global_object());
       case ScopeIterator::ScopeTypeScript:
         return MaterializeScriptScope(
             Handle<GlobalObject>(CurrentContext()->global_object()));
       case ScopeIterator::ScopeTypeLocal:
         // Materialize the content of the local scope into a JSObject.
         DCHECK(nested_scope_chain_.length() == 1);
-        return MaterializeLocalScope(isolate_, frame_inspector_);
+        return MaterializeLocalScope(isolate_, frame_, inlined_jsframe_index_);
       case ScopeIterator::ScopeTypeWith:
         // Return the with object.
         return Handle<JSObject>(JSObject::cast(CurrentContext()->extension()));
       case ScopeIterator::ScopeTypeCatch:
         return MaterializeCatchScope(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeClosure:
         // Materialize the content of the closure scope into a JSObject.
         return MaterializeClosure(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeBlock: {
         if (!nested_scope_chain_.is_empty()) {
           // this is a block scope on the stack.
           Handle<ScopeInfo> scope_info = nested_scope_chain_.last();
           Handle<Context> context = scope_info->HasContext()
                                         ? CurrentContext()
                                         : Handle<Context>::null();
-          return MaterializeBlockScope(isolate_, scope_info, context,
-                                       frame_inspector_);
+          return MaterializeBlockScope(isolate_, scope_info, context, frame_,
+                                       inlined_jsframe_index_);
         } else {
           return MaterializeBlockScope(isolate_, Handle<ScopeInfo>::null(),
-                                       CurrentContext(), nullptr);
+                                       CurrentContext(), nullptr, 0);
         }
       }
       case ScopeIterator::ScopeTypeModule:
         return MaterializeModuleScope(isolate_, CurrentContext());
     }
     UNREACHABLE();
     return Handle<JSObject>();
   }
 
   bool HasContext() {
     ScopeType type = Type();
     if (type == ScopeTypeBlock || type == ScopeTypeLocal) {
       if (!nested_scope_chain_.is_empty()) {
         return nested_scope_chain_.last()->HasContext();
       }
     }
     return true;
   }
 
   bool SetVariableValue(Handle<String> variable_name,
                         Handle<Object> new_value) {
     DCHECK(!failed_);
     switch (Type()) {
       case ScopeIterator::ScopeTypeGlobal:
         break;
       case ScopeIterator::ScopeTypeLocal:
-        return SetLocalVariableValue(isolate_, frame(), variable_name,
-                                     new_value);
+        return SetLocalVariableValue(isolate_, frame_, inlined_jsframe_index_,
+                                     variable_name, new_value);
       case ScopeIterator::ScopeTypeWith:
         break;
       case ScopeIterator::ScopeTypeCatch:
         return SetCatchVariableValue(isolate_, CurrentContext(), variable_name,
                                      new_value);
       case ScopeIterator::ScopeTypeClosure:
         return SetClosureVariableValue(isolate_, CurrentContext(),
                                        variable_name, new_value);
       case ScopeIterator::ScopeTypeScript:
         return SetScriptVariableValue(CurrentContext(), variable_name,
                                       new_value);
       case ScopeIterator::ScopeTypeBlock:
         return SetBlockVariableValue(
             isolate_, HasContext() ? CurrentContext() : Handle<Context>::null(),
-            CurrentScopeInfo(), frame(), variable_name, new_value);
+            CurrentScopeInfo(), frame_, variable_name, new_value);
       case ScopeIterator::ScopeTypeModule:
         // TODO(2399): should we implement it?
         break;
     }
     return false;
   }
 
   Handle<ScopeInfo> CurrentScopeInfo() {
     DCHECK(!failed_);
     if (!nested_scope_chain_.is_empty()) {
@@ skipping 26 matching lines @@
     OFStream os(stdout);
     DCHECK(!failed_);
     switch (Type()) {
       case ScopeIterator::ScopeTypeGlobal:
         os << "Global:\n";
         CurrentContext()->Print(os);
         break;
 
       case ScopeIterator::ScopeTypeLocal: {
         os << "Local:\n";
-        function()->shared()->scope_info()->Print();
+        function_->shared()->scope_info()->Print();
         if (!CurrentContext().is_null()) {
           CurrentContext()->Print(os);
           if (CurrentContext()->has_extension()) {
             Handle<Object> extension(CurrentContext()->extension(), isolate_);
             if (extension->IsJSContextExtensionObject()) {
               extension->Print(os);
             }
           }
         }
         break;
@@ skipping 32 matching lines @@
 
       default:
         UNREACHABLE();
     }
     PrintF("\n");
   }
 #endif
 
  private:
   Isolate* isolate_;
-  FrameInspector* const frame_inspector_;
+  JavaScriptFrame* frame_;
+  int inlined_jsframe_index_;
+  Handle<JSFunction> function_;
   Handle<Context> context_;
   List<Handle<ScopeInfo> > nested_scope_chain_;
   bool seen_script_scope_;
   bool failed_;
 
-  inline JavaScriptFrame* frame() {
-    return frame_inspector_->GetArgumentsFrame();
-  }
-
-  inline JSFunction* function() {
-    return JSFunction::cast(frame_inspector_->GetFunction());
-  }
-
   void RetrieveScopeChain(Scope* scope,
                           Handle<SharedFunctionInfo> shared_info) {
     if (scope != NULL) {
-      int source_position = frame_inspector_->GetSourcePosition();
+      int source_position = shared_info->code()->SourcePosition(frame_->pc());
       scope->GetNestedScopeChain(isolate_, &nested_scope_chain_,
                                  source_position);
     } else {
       // A failed reparse indicates that the preparser has diverged from the
       // parser or that the preparse data given to the initial parse has been
       // faulty. We fail in debug mode but in release mode we only provide the
       // information we get from the context chain but nothing about
       // completely stack allocated scopes or stack allocated locals.
       // Or it could be due to stack overflow.
       DCHECK(isolate_->has_pending_exception());
@@ skipping 10 matching lines @@
   DCHECK(args.length() == 2);
   CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
   RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
 
   CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
 
   // Get the frame where the debugging is performed.
   StackFrame::Id id = UnwrapFrameId(wrapped_id);
   JavaScriptFrameIterator it(isolate, id);
   JavaScriptFrame* frame = it.frame();
-  FrameInspector frame_inspector(frame, 0, isolate);
 
   // Count the visible scopes.
   int n = 0;
-  for (ScopeIterator it(isolate, &frame_inspector); !it.Done(); it.Next()) {
+  for (ScopeIterator it(isolate, frame, 0); !it.Done(); it.Next()) {
     n++;
   }
 
   return Smi::FromInt(n);
 }
 
 
 // Returns the list of step-in positions (text offset) in a function of the
 // stack frame in a range from the current debug break position to the end
 // of the corresponding statement.
@@ skipping 104 matching lines @@
   RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
 
   CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
   CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
   CONVERT_NUMBER_CHECKED(int, index, Int32, args[3]);
 
   // Get the frame where the debugging is performed.
   StackFrame::Id id = UnwrapFrameId(wrapped_id);
   JavaScriptFrameIterator frame_it(isolate, id);
   JavaScriptFrame* frame = frame_it.frame();
-  FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
 
   // Find the requested scope.
   int n = 0;
-  ScopeIterator it(isolate, &frame_inspector);
+  ScopeIterator it(isolate, frame, inlined_jsframe_index);
   for (; !it.Done() && n < index; it.Next()) {
     n++;
   }
   if (it.Done()) {
     return isolate->heap()->undefined_value();
   }
   Handle<JSObject> details;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
                                      MaterializeScopeDetails(isolate, &it));
   return *details;
@@ skipping 21 matching lines @@
   bool ignore_nested_scopes = false;
   if (args.length() == 4) {
     CONVERT_BOOLEAN_ARG_CHECKED(flag, 3);
     ignore_nested_scopes = flag;
   }
 
   // Get the frame where the debugging is performed.
   StackFrame::Id id = UnwrapFrameId(wrapped_id);
   JavaScriptFrameIterator frame_it(isolate, id);
   JavaScriptFrame* frame = frame_it.frame();
-  FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
 
   List<Handle<JSObject> > result(4);
-  ScopeIterator it(isolate, &frame_inspector, ignore_nested_scopes);
+  ScopeIterator it(isolate, frame, inlined_jsframe_index, ignore_nested_scopes);
   for (; !it.Done(); it.Next()) {
     Handle<JSObject> details;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
                                        MaterializeScopeDetails(isolate, &it));
     result.Add(details);
   }
 
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length());
   for (int i = 0; i < result.length(); ++i) {
     array->set(i, *result[i]);
@@ skipping 80 matching lines @@
     CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
     RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
 
     CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
     CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
 
     // Get the frame where the debugging is performed.
     StackFrame::Id id = UnwrapFrameId(wrapped_id);
     JavaScriptFrameIterator frame_it(isolate, id);
     JavaScriptFrame* frame = frame_it.frame();
-    FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
 
-    ScopeIterator it(isolate, &frame_inspector);
+    ScopeIterator it(isolate, frame, inlined_jsframe_index);
     res = SetScopeVariableValue(&it, index, variable_name, new_value);
   } else {
     CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
     ScopeIterator it(isolate, fun);
     res = SetScopeVariableValue(&it, index, variable_name, new_value);
   }
 
   return isolate->heap()->ToBoolean(res);
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugPrintScopes) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 0);
 
 #ifdef DEBUG
   // Print the scopes for the top frame.
   StackFrameLocator locator(isolate);
   JavaScriptFrame* frame = locator.FindJavaScriptFrame(0);
-  FrameInspector frame_inspector(frame, 0, isolate);
-
-  for (ScopeIterator it(isolate, &frame_inspector); !it.Done(); it.Next()) {
+  for (ScopeIterator it(isolate, frame, 0); !it.Done(); it.Next()) {
     it.DebugPrint();
   }
 #endif
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_GetThreadCount) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
@@ skipping 372 matching lines @@
         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;
 
     bool stop = false;
-    for (ScopeIterator it(isolate, &frame_inspector);
+    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<Context> parent_context =
             it.HasContext() ? it.CurrentContext() : outer_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".
         parent_context =
@@ skipping 725 matching lines @@
   return *isolate->factory()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugBreakInOptimizedCode) {
   UNIMPLEMENTED();
   return NULL;
 }
 }  // namespace internal
 }  // namespace v8