[debug-wrapper] migrate some scope related tests

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 432 matching lines @@
       const elem = serialized_scope[i];
       if (elem.name == prop) {
         found = elem;
         break;
       }
     }
 
     if (found == null) return { isUndefined : () => true };
 
     const val = { value : () => found.value.value };
+    // Not undefined in the sense that we did find a property, even though
+    // the value can be 'undefined'.
     return { value : () => val,
-             isUndefined : () => found.value.type == "undefined"
+             isUndefined : () => false,
            };
   }
 
   // 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 serialized_scope = this.getProperties(obj.objectId);
     const scope = this.propertiesToObject(serialized_scope);
     return { value : () => scope,
              property : (prop) =>
-                 this.execStateScopeObjectProperty(serialized_scope, prop)
+                 this.execStateScopeObjectProperty(serialized_scope, prop),
+             properties : () => serialized_scope.map(elem => elem.value),
+             propertyNames : () => serialized_scope.map(elem => elem.name)
            };
   }
 
+  execStateScopeDetails(scope) {
+    var start_position;
+    var end_position
+    const start = scope.startLocation;
+    const end = scope.endLocation;
+    if (start) {
+      start_position = %ScriptLocationFromLine2(
+          parseInt(start.scriptId), start.lineNumber, start.columnNumber, 0)
+          .position;
+    }
+    if (end) {
+      end_position = %ScriptLocationFromLine2(
+          parseInt(end.scriptId), end.lineNumber, end.columnNumber, 0)
+          .position;
+    }
+    return { name : () => scope.name,
+             startPosition : () => start_position,
+             endPosition : () => end_position
+           };
+  }
+
   setVariableValue(frame, scope_index, name, value) {
     const frameid = frame.callFrameId;
     const {msgid, msg} = this.createMessage(
         "Debugger.setVariableValue",
         { callFrameId : frameid,
           scopeNumber : scope_index,
           variableName : name,
           newValue : { value : value }
         });
     this.sendMessage(msg);
     const reply = this.takeReplyChecked(msgid);
     if (reply.error) {
       throw new Error("Failed to set variable value");
     }
   }
 
   execStateScope(frame, scope_index) {
     const scope = frame.scopeChain[scope_index];
     return { scopeType : () => this.execStateScopeType(scope.type),
+             scopeIndex : () => scope_index,
+             frameIndex : () => frame.callFrameId,
              scopeObject : () => this.execStateScopeObject(scope.object),
              setVariableValue :
                 (name, value) => this.setVariableValue(frame, scope_index,
-                                                       name, value)
+                                                       name, value),
+             details : () => this.execStateScopeDetails(scope)
            };
   }
 
   // Takes a list of properties as produced by getProperties and turns them
   // into an object.
   propertiesToObject(props) {
     const obj = {}
     props.forEach((elem) => {
       const key = elem.name;
 
@@ skipping 149 matching lines @@
         { callFrameId : frameid,
           expression : expr
         });
     this.sendMessage(msg);
     const reply = this.takeReplyChecked(msgid);
 
     const result = reply.result.result;
     return this.reconstructRemoteObject(result);
   }
 
+  frameReceiver(frame) {
+    return this.reconstructRemoteObject(frame.this);
+  }
+
+  frameReturnValue(frame) {
+    return this.reconstructRemoteObject(frame.returnValue);
+  }
+
   execStateFrameRestart(frame) {
     const frameid = frame.callFrameId;
     const {msgid, msg} = this.createMessage(
         "Debugger.restartFrame", { callFrameId : frameid });
     this.sendMessage(msg);
     this.takeReplyChecked(msgid);
   }
 
   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 };
     const index = JSON.parse(frame.callFrameId).ordinal;
 
     function allScopes() {
       const scopes = [];
       for (let i = 0; i < frame.scopeChain.length; i++) {
         scopes.push(this.execStateScope(frame, i));
       }
       return scopes;
-    };
+    }
 
     return { sourceColumn : () => column,
              sourceLine : () => line + 1,
              sourceLineText : () => loc.sourceText,
+             sourcePosition : () => loc.position,
              evaluate : (expr) => this.evaluateOnCallFrame(frame, expr),
              functionName : () => frame.functionName,
              func : () => func,
              index : () => index,
              localCount : () => this.execStateFrameLocalCount(frame),
              localName : (ix) => this.execStateFrameLocalName(frame, ix),
              localValue: (ix) => this.execStateFrameLocalValue(frame, ix),
-             receiver : () => this.evaluateOnCallFrame(frame, "this"),
+             receiver : () => this.frameReceiver(frame),
              restart : () => this.execStateFrameRestart(frame),
+             returnValue : () => this.frameReturnValue(frame),
              scopeCount : () => frame.scopeChain.length,
              scope : (index) => this.execStateScope(frame, index),
              allScopes : allScopes.bind(this)
            };
   }
 
+  execStateEvaluateGlobal(expr) {
+    const {msgid, msg} = this.createMessage(
+        "Runtime.evaluate", { expression : expr });
+    this.sendMessage(msg);
+    const reply = this.takeReplyChecked(msgid);
+
+    const result = reply.result.result;
+    return this.reconstructRemoteObject(result);
+  }
+
   eventDataException(params) {
     switch (params.data.type) {
       case "string": {
         return params.data.value;
       }
       case "object": {
         const props = this.getProperties(params.data.objectId);
         return this.propertiesToObject(props);
       }
       default: {
@@ skipping 55 matching lines @@
         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),
+                      evaluateGlobal :
+                        (expr) => this.execStateEvaluateGlobal(expr),
                       frame : (index) => this.execStateFrame(
                           index ? params.callFrames[index]
                                 : params.callFrames[0]),
                       frameCount : () => params.callFrames.length
                     };
 
     let eventData = this.execStateFrame(params.callFrames[0]);
     if (debugEvent == this.DebugEvent.Exception) {
       eventData.uncaught = () => params.data.uncaught;
       eventData.exception = () => this.eventDataException(params);
@@ skipping 43 matching lines @@
     debug.instance = new DebugWrapper();
     debug.instance.enable();
   }
   return debug.instance;
 }});
 
 Object.defineProperty(debug, 'ScopeType', { get: function() {
   const instance = debug.Debug;
   return instance.ScopeType;
 }});