Devtools: expose scopes source location to debugger

src/debug/debug-scopes.h

 // 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.
 
 #ifndef V8_DEBUG_DEBUG_SCOPES_H_
 #define V8_DEBUG_DEBUG_SCOPES_H_
 
 #include "src/debug/debug-frames.h"
 #include "src/frames.h"
 
@@ skipping 13 matching lines @@
     ScopeTypeClosure,
     ScopeTypeCatch,
     ScopeTypeBlock,
     ScopeTypeScript,
     ScopeTypeModule
   };
 
   static const int kScopeDetailsTypeIndex = 0;
   static const int kScopeDetailsObjectIndex = 1;
   static const int kScopeDetailsNameIndex = 2;
-  static const int kScopeDetailsSize = 3;
+  static const int kScopeDetailsStartPositionIndex = 3;
+  static const int kScopeDetailsEndPositionIndex = 4;
+  static const int kScopeDetailsFunctionIndex = 5;
+  static const int kScopeDetailsSize = 6;
 
   enum Option { DEFAULT, IGNORE_NESTED_SCOPES, COLLECT_NON_LOCALS };
 
   ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
                 Option options = DEFAULT);
 
   ScopeIterator(Isolate* isolate, Handle<JSFunction> function);
 
   ~ScopeIterator() { delete non_locals_; }
 
@@ skipping 31 matching lines @@
   void GetNonLocals(List<Handle<String> >* list_out);
 
   bool ThisIsNonLocal();
 
 #ifdef DEBUG
   // Debug print of the content of the current scope.
   void DebugPrint();
 #endif
 
  private:
+  struct ExtendedScopeInfo {
+    ExtendedScopeInfo(Handle<ScopeInfo> info, int start, int end)
+        : scope_info(info), start_position(start), end_position(end) {}
+    Handle<ScopeInfo> scope_info;
+    int start_position;
+    int end_position;
+  };
+
   Isolate* isolate_;
   FrameInspector* const frame_inspector_;
   Handle<Context> context_;
-  List<Handle<ScopeInfo> > nested_scope_chain_;
+  List<ExtendedScopeInfo> nested_scope_chain_;
   HashMap* non_locals_;
   bool seen_script_scope_;
   bool failed_;
 
   inline JavaScriptFrame* GetFrame() {
     return frame_inspector_->GetArgumentsFrame();
   }
 
   inline Handle<JSFunction> GetFunction() {
     return Handle<JSFunction>::cast(frame_inspector_->GetFunction());
@@ skipping 33 matching lines @@
                             Handle<String> variable_name,
                             Handle<Object> new_value);
 
   void CopyContextLocalsToScopeObject(Handle<ScopeInfo> scope_info,
                                       Handle<Context> context,
                                       Handle<JSObject> scope_object);
   bool CopyContextExtensionToScopeObject(Handle<JSObject> extension,
                                          Handle<JSObject> scope_object,
                                          KeyCollectionType type);
 
+  // Get the chain of nested scopes within this scope for the source statement
+  // position. The scopes will be added to the list from the outermost scope to
+  // the innermost scope. Only nested block, catch or with scopes are tracked
+  // and will be returned, but no inner function scopes.
+  void GetNestedScopeChain(Isolate* isolate, Scope* scope,
+                           int statement_position);
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(ScopeIterator);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_SCOPES_H_