[debugger] Basic scope functionality and exception events in wrapper

test/debugger/test-api.js

 // Copyright 2016 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.
 
 "use strict";
 
 // If true, prints all messages sent and received by inspector.
 const printProtocolMessages = false;
 
 // The active wrapper instance.
@@ skipping 202 matching lines @@
 
   execStatePrepareStep(action) {
     switch(action) {
       case this.StepAction.StepOut: this.stepOut(); break;
       case this.StepAction.StepNext: this.stepOver(); break;
       case this.StepAction.StepIn: this.stepInto(); break;
       default: %AbortJS("Unsupported StepAction"); break;
     }
   }
 
+  execStateScopeType(type) {
+    switch (type) {
+      case "global": return this.ScopeType.Global;
+      case "local": return this.ScopeType.Local;
+      case "with": return this.ScopeType.With;
+      case "closure": return this.ScopeType.Closure;
+      case "catch": return this.ScopeType.Catch;
+      case "block": return this.ScopeType.Block;
+      case "script": return this.ScopeType.Script;
+      default: %AbortJS("Unexpected scope type");
+    }
+  }
+
+  // Returns an array of property descriptors of the scope object.
+  // This is in contrast to the original API, which simply passed object
+  // mirrors.
+  execStateScopeObject(obj) {
+    const {msgid, msg} = this.createMessage(
+        "Runtime.getProperties", { objectId : obj.objectId });
+    this.sendMessage(msg);
+    const reply = this.takeReplyChecked(msgid);
+    return { value : () => reply.result.result };
+  }
+
   execStateScope(scope) {
-    // TODO(jgruber): Mapping
-    return { scopeType: () => scope.type,
-             scopeObject: () => scope.object
+    return { scopeType : () => this.execStateScopeType(scope.type),

[Yang, 2016/11/08 13:37:33]

Just curious: do we need to specify 'this' explicitly here?

[jgruber, 2016/11/08 13:58:35]

We do :/

$ out/debug/d8 <<< 'class Foo { x() { print("Hello World"); } y() { x(); } };
new Foo().y();'
V8 version 5.6.0 (candidate)
d8> (d8):1: ReferenceError: x is not defined
class Foo { x() { print("Hello World"); } y() { x(); } }; new Foo().y();
                                                ^
ReferenceError: x is not defined
    at Foo.y ((d8):1:49)
    at (d8):1:69

+             scopeObject : () => this.execStateScopeObject(scope.object)
            };
   }
 
   execStateFrame(frame) {
     const scriptid = parseInt(frame.location.scriptId);
     const line = frame.location.lineNumber;
     const column = frame.location.columnNumber;
     const loc = %ScriptLocationFromLine2(scriptid, line, column, 0);
     const func = { name : () => frame.functionName };
     return { sourceLineText : () => loc.sourceText,
              functionName : () => frame.functionName,
              func : () => func,
              scopeCount : () => frame.scopeChain.length,
              scope : (index) => this.execStateScope(frame.scopeChain[index])
+           , allScopes : () => frame.scopeChain.map(this.execStateScope.bind(this))

[Yang, 2016/11/08 13:37:33]

formatting (comma, and 80-char limit) :)

[jgruber, 2016/11/08 13:58:35]

Done, ty.

            };
   }
 
   // --- Message handlers. -----------------------------------------------------
 
   dispatchMessage(message) {
     const method = message.method;
     if (method == "Debugger.paused") {
       this.handleDebuggerPaused(message);
     } else if (method == "Debugger.scriptParsed") {
       this.handleDebuggerScriptParsed(message);
     }
   }
 
   handleDebuggerPaused(message) {
     const params = message.params;
 
+    var debugEvent;
+    switch (params.reason) {
+      case "exception":
+      case "promiseRejection":
+        debugEvent = this.DebugEvent.Exception;
+        break;
+      default:
+        // TODO(jgruber): More granularity.
+        debugEvent = this.DebugEvent.Break;
+        break;
+    }
+
     // Skip break events in this file.
     if (params.callFrames[0].location.scriptId == this.thisScriptId) return;
 
     // TODO(jgruber): Arguments as needed.
     let execState = { frames : params.callFrames,
                       prepareStep : this.execStatePrepareStep.bind(this),
                       frame : (index) => this.execStateFrame(
                           index ? params.callFrames[index]
                                 : params.callFrames[0]),
                       frameCount : () => params.callFrames.length
                     };
     let eventData = this.execStateFrame(params.callFrames[0]);
-    this.invokeListener(this.DebugEvent.Break, execState, eventData);
+    this.invokeListener(debugEvent, execState, eventData);
   }
 
   handleDebuggerScriptParsed(message) {
     const params = message.params;
     let eventData = { scriptId : params.scriptId,
                       eventType : this.DebugEvent.AfterCompile
                     }
 
     // TODO(jgruber): Arguments as needed. Still completely missing exec_state,
     // and eventData used to contain the script mirror instead of its id.
     this.invokeListener(this.DebugEvent.AfterCompile, undefined, eventData,
                         undefined);
   }
 
   invokeListener(event, exec_state, event_data, data) {
     if (this.listener) {
       this.listener(event, exec_state, event_data, data);
     }
   }
 }
 
 // Simulate the debug object generated by --expose-debug-as debug.
 var debug = { instance : undefined };
+
 Object.defineProperty(debug, 'Debug', { get: function() {
   if (!debug.instance) {
     debug.instance = new DebugWrapper();
     debug.instance.enable();
   }
   return debug.instance;
 }});
+
+Object.defineProperty(debug, 'ScopeType', { get: function() {
+  const instance = debug.Debug;
+  return instance.ScopeType;
+}});