Inspect local variables and fields from service protocol.

pkg/dartino_compiler/lib/src/debug_service_protocol.dart

 // Copyright (c) 2016, the Dartino project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 /// An implementation of the vm service-protocol in terms of a DartinoVmContext.
 /// Processes are mapped to isolates.
 // TODO(sigurdm): Handle processes better.
 // TODO(sigurdm): Find a way to represent fibers.
-// TODO(sigurdm): Represent remote values.
 // TODO(sigurdm): Use https://pub.dartlang.org/packages/json_rpc_2 for serving.
 
 import "dart:async" show Future;
 
 import 'dart:convert' show JSON;
 
 import 'dart:io' show File, HttpServer, WebSocket, WebSocketTransformer;
 
 import 'hub/session_manager.dart' show SessionState;
 
 import 'guess_configuration.dart' show dartinoVersion;
 
 import '../debug_state.dart'
-    show BackTrace, BackTraceFrame, Breakpoint, RemoteObject;
+    show
+        BackTrace,
+        BackTraceFrame,
+        Breakpoint,
+        RemoteArray,
+        RemoteErrorObject,
+        RemoteInstance,
+        RemoteObject,
+        RemoteValue;
 
 import '../vm_context.dart' show DartinoVmContext, DebugListener;
 
 import '../dartino_system.dart'
     show DartinoFunction, DartinoFunctionKind, DartinoSystem;
 
 import 'debug_info.dart' show DebugInfo, ScopeInfo, SourceLocation;
 
 import 'dartino_compiler_implementation.dart'
     show DartinoCompilerImplementation;
-
-import 'codegen_visitor.dart' show LocalValue;
+import 'element_utils.dart';
 
 import '../program_info.dart' show Configuration;
+import '../vm_commands.dart'
+    show
+        Array,
+        Boolean,
+        ClassValue,
+        DartValue,
+        Double,
+        Instance,
+        Integer,
+        NullValue,
+        StringValue;
 
 import 'package:collection/collection.dart' show binarySearch;
 
 import 'package:compiler/src/scanner/scanner.dart' show Scanner;
 import 'package:compiler/src/tokens/token.dart' show Token;
 import 'package:compiler/src/io/source_file.dart' show SourceFile;
 import 'package:compiler/src/elements/visitor.dart' show BaseElementVisitor;
 import 'package:compiler/src/elements/elements.dart'
     show
+        ClassElement,
         CompilationUnitElement,
         Element,
+        FieldElement,
         FunctionElement,
         LibraryElement,
         MemberElement,
         ScopeContainerElement;
 
 const bool logging = const bool.fromEnvironment("dartino-log-debug-server");
 
-//TODO(danrubel): Verify const map values
-const Map<String, dynamic> dartCoreLibRefDesc = const <String, dynamic>{
-  "type": "@Library",
-  "id": "libraries/dart:core",
-  "fixedId": true,
-  "name": "dart:core",
-  "uri": "dart:core",
-};
-
-//TODO(danrubel): Verify correct id
-const String nullId = "objects/Null";
-
-//TODO(danrubel): Verify const map values
-const Map<String, dynamic> nullClassRefDesc = const <String, dynamic>{
-  "type": "@Class",
-  "id": "classes/NullClass",
-  "name": "NullClass",
-};
-
-//TODO(danrubel): Verify const map values
-const Map<String, dynamic> nullRefDesc = const <String, dynamic>{
-  "type": "@Null",
-  "id": nullId,
-  "kind": "Null",
-  "class": nullClassRefDesc,
-  "valueAsString": "null",
-};
-
-//TODO(danrubel): Verify const map values
-const Map<String, dynamic> nullDesc = const <String, dynamic>{
-  "type": "Null",
-  "id": nullId,
-  "kind": "Null",
-  "class": nullClassRefDesc,
-  "valueAsString": "null",
-};
-
 class DebugServer {
   Future<int> serveSingleShot(SessionState state,
       {int port: 0, Uri snapshotLocation}) async {
     HttpServer server = await HttpServer.bind("127.0.0.1", port);
     // The Atom Dartino plugin waits for "localhost:<port-number>"
     // to determine the observatory port for debugging.
     print("localhost:${server.port}");
     WebSocket socket = await server.transform(new WebSocketTransformer()).first;
     await new DebugConnection(state, socket, snapshotLocation: snapshotLocation)
         .serve();
@@ skipping 35 matching lines @@
     socket.add(JSON.encode(message));
   }
 
   void setStream(String streamId, bool value) {
     streams[streamId] = value;
   }
 
   Map<String, CompilationUnitElement> scripts =
       new Map<String, CompilationUnitElement>();
 
-  Map frameDesc(BackTraceFrame frame, int index) {
+  Future<Map> frameDesc(BackTraceFrame frame, int index) async {
     List<Map> vars = new List<Map>();
     for (ScopeInfo current = frame.scopeInfo();
         current != ScopeInfo.sentinel;
         current = current.previous) {
+      RemoteValue remoteValue =
+          await vmContext.processLocal(index, current.local.slot);
       vars.add({
         "type": "BoundVariable",
         "name": current.name,
-        "value": valueDesc(current.lookup(current.name))
+        "value": instanceRef(
+            remoteValue.value, "objects/$index.${current.local.slot}"),
       });
+      print("Adding ${vars.last}");

[Søren Gjesse, 2016/06/15 11:26:18]

Debug print.

[sigurdm, 2016/06/17 07:29:32]

Done.

     }
     return {
       "type": "Frame",
       "index": index,
       "function": functionRef(frame.function),
       "code": {
         "id": "code-id", //TODO(danrubel): what is the unique id here?
         "type": "@Code",
         "name": "code-name", // TODO(sigurdm): How to create a name here?
         "kind": "Dart",
@@ skipping 163 matching lines @@
       "type": "Function",
       "id": "functions/${function.functionId}",
       // TODO(sigurdm): All kinds of owner.
       "owner": libraryRef(element.library),
       "static": element.isStatic,
       "const": element.isConst,
       "_kind": functionKind(function.kind),
     };
   }
 
-  Map valueDesc(LocalValue lookup) {
-    //TODO(danrubel): Translate local value into description?
-    // Need to return an @InstanceRef or Sentinel
-    return nullRefDesc;
+  Map classRef(ClassElement classElement) {
+    if (classElement == null) {
+      return {"type": "@Class", "id": "unknown", "name": "unknown class"};
+    }
+    String symbolicName =
+        "${classElement.library.canonicalUri}.${classElement.name}";
+    return {
+      "type": "@Class",
+      "id": "classes/$symbolicName",
+      "name": "${classElement.name}",
+    };
+  }
+
+  Map instanceRef(DartValue value, String id) {
+    int classId;
+    Element classElement;
+    String stringValue;
+    String kind;
+    int length;
+    String name;
+    if (value is Instance) {
+      kind = "PlainInstance";
+      classId = value.classId;
+    } else if (value is Integer) {
+      kind = "Int";
+      classElement = vmContext.compiler.compiler.backend.intImplementation;
+      stringValue = "${value.value}";
+    } else if (value is StringValue) {
+      kind = "String";
+      classElement = vmContext.compiler.compiler.backend.stringImplementation;
+      stringValue = value.value;
+    } else if (value is Boolean) {
+      kind = "Bool";
+      classElement = vmContext.compiler.compiler.backend.boolImplementation;
+      stringValue = "${value.value}";
+    } else if (value is Double) {
+      kind = "Double";
+      classElement = vmContext.compiler.compiler.backend.doubleImplementation;
+      stringValue = "${value.value}";
+    } else if (value is ClassValue) {
+      kind = "Type";
+      Element element =
+          vmContext.dartinoSystem.classesById[value.classId].element;
+      classElement = vmContext.compiler.compiler.backend.typeImplementation;
+      name = "${element}";
+    } else if (value is NullValue) {
+      kind = "Null";
+      classElement = vmContext.compiler.compiler.backend.nullImplementation;
+      stringValue = "null";
+    } else if (value is Array) {
+      kind = "List";
+      classElement = vmContext.compiler.compiler.backend.listImplementation;
+      length = value.length;
+    } else {
+      throw "Unexpected remote value $value";
+    }
+    print("classId $classId element $classElement");

[Søren Gjesse, 2016/06/15 11:26:18]

Debug print.

[sigurdm, 2016/06/17 07:29:32]

Done.

+    Map classReference = classRef(
+        classElement ?? vmContext.dartinoSystem.classesById[classId]?.element);
+    Map result = {
+      "type": "@Instance",
+      "id": id,
+      "kind": kind,
+      "class": classReference,
+    };
+    if (stringValue != null) {
+      result["valueAsString"] = stringValue;
+    }
+    if (length != null) {
+      result["length"] = length;
+    }
+    if (name != null) {
+      result["name"] = name;
+    }
+    return result;
+  }
+
+  Map instanceDesc(RemoteObject remoteObject, String id) {
+    // TODO(sigurdm): Allow inspecting any frame.
+    assert(remoteObject is! RemoteErrorObject);
+    if (remoteObject is RemoteInstance) {
+      int classId = remoteObject.instance.classId;
+      Element classElement =
+          vmContext.dartinoSystem.classesById[classId].element;
+      List<FieldElement> fieldElements = computeFields(classElement);
+      assert(fieldElements.length == remoteObject.fields.length);
+      List fields = new List();
+      for (int i = 0; i < fieldElements.length; i++) {
+        FieldElement fieldElement = fieldElements[i];
+        fields.add({
+          "type": "BoundField",
+          "decl": {
+            "type": "@Field",
+            "name": fieldElement.name,
+            "owner": classRef(fieldElement.contextClass),
+            "declaredType": null, // TODO(sigurdm): fill this in.
+            "const": fieldElement.isConst,
+            "final": fieldElement.isFinal,
+            "static": fieldElement.isStatic,
+          },
+          "value": instanceRef(remoteObject.fields[i], "$id.$i"),
+        });
+      }
+      return <String, dynamic>{
+        "type": "Instance",
+        "id": id,
+        "kind": "PlainInstance",
+        "class": classRef(classElement),
+        "fields": fields,
+      };
+    } else if (remoteObject is RemoteArray) {

[Søren Gjesse, 2016/06/15 11:26:18]

Probably want to have a TODO on handling large arrays, so that only part of the
elements are transferred initially, and then can be fetched on demand.

Does the protocol support the concept of partial arrays?

[sigurdm, 2016/06/17 07:29:32]

Added TODO.
It does - I don't know the details of how it works though.

+      List elements = new List();
+      for (int i = 0; i < remoteObject.array.length; i++) {
+        elements.add(instanceRef(remoteObject.values[i], "$id.$i"));
+      }
+      return <String, dynamic>{
+        "type": "Instance",
+        "id": id,
+        "kind": "List",
+        "class":
+            classRef(vmContext.compiler.compiler.backend.listImplementation),
+        "elements": elements,
+      };
+    } else if (remoteObject is RemoteValue) {
+      Map instance = instanceRef(remoteObject.value, id);
+      instance["type"] = "Instance";
+      return instance;
+    } else {
+      throw "Unexpected remote object kind";
+    }
   }
 
   initialize(DartinoCompilerImplementation compiler) {
     for (LibraryElement library in compiler.libraryLoader.libraries) {
       cacheScripts(LibraryElement library) {
         for (CompilationUnitElement compilationUnit
             in library.compilationUnits) {
           Uri uri = compilationUnit.script.file.uri;
           scripts["scripts/$uri"] = compilationUnit;
           tokenTables[uri] = makeTokenTable(compilationUnit);
@@ skipping 142 matching lines @@
                   .lookupLibrary(Uri.parse(uri))));
               break;
             case "scripts":
               sendResult(scriptDesc(scripts[id]));
               break;
             case "functions":
               sendResult(functionDesc(vmContext.dartinoSystem.functionsById[
                   int.parse(id.substring(slashIndex + 1))]));
               break;
             case "objects":
-              if (id == nullId) {
-                sendResult(nullDesc);
-              } else {
-                //TODO(danrubel): Need to return an Instance description
-                // or Sentinel for the given @InstanceRef
-                throw 'Unknown object: $id';
-              }
+              String path = id.substring(slashIndex + 1);
+              List<int> dotted = path.split(".").map(int.parse).toList();
+              int localFrame = dotted.first;
+              int localSlot = dotted[1];
+              List<int> fieldAccesses = dotted.skip(2).toList();
+              RemoteObject remoteObject = await vmContext.processLocalStructure(
+                  localFrame, localSlot,
+                  fieldAccesses: fieldAccesses);
+              sendResult(instanceDesc(remoteObject, id));
               break;
             default:
               throw "Unsupported object type $id";
           }
           break;
         case "getStack":
           String isolateIdString = decodedMessage["params"]["isolateId"];
           int isolateId = int.parse(
               isolateIdString.substring(isolateIdString.indexOf("/") + 1));
           BackTrace backTrace =
               await state.vmContext.backTrace(processId: isolateId);
           List frames = [];
           int index = 0;
           for (BackTraceFrame frame in backTrace.frames) {
-            frames.add(frameDesc(frame, index));
+            frames.add(await frameDesc(frame, index));
             index++;
           }
 
           sendResult({"type": "Stack", "frames": frames, "messages": [],});
           break;
         case "getSourceReport":
           String scriptId = decodedMessage["params"]["scriptId"];
           CompilationUnitElement compilationUnit = scripts[scriptId];
           Uri scriptUri = compilationUnit.script.file.uri;
           List<int> tokenTable = tokenTables[scriptUri];
@@ skipping 164 matching lines @@
     // TODO(sigurdm): Implement gc notification.
   }
 
   @override
   lostConnection() {
     socket.close();
   }
 
   @override
   pauseBreakpoint(
-      int processId, BackTraceFrame topFrame, Breakpoint breakpoint) {
+      int processId, BackTraceFrame topFrame, Breakpoint breakpoint) async {
     //TODO(danrubel): are there any other breakpoints
     // at which we are currently paused for a PauseBreakpoint event?
     List<Breakpoint> pauseBreakpoints = <Breakpoint>[];
     pauseBreakpoints.add(breakpoint);
     Map event = {
       "type": "Event",
       "kind": "PauseBreakpoint",
       "isolate": isolateRef(processId),
       "timestamp": new DateTime.now().millisecondsSinceEpoch,
-      "topFrame": frameDesc(topFrame, 0),
+      "topFrame": await frameDesc(topFrame, 0),
       "atAsyncSuspension": false,
       "breakpoint": breakpointDesc(breakpoint),
       "pauseBreakpoints":
           new List.from(pauseBreakpoints.map((bp) => breakpointDesc(bp))),
     };
     lastPauseEvent = event;
     streamNotify("Debug", event);
   }
 
   @override
-  pauseException(int processId, BackTraceFrame topFrame, RemoteObject thrown) {
+  pauseException(
+      int processId, BackTraceFrame topFrame, RemoteObject thrown) async {
     Map event = {
       "type": "Event",
       "kind": "PauseException",
       "isolate": isolateRef(processId),
       "timestamp": new DateTime.now().millisecondsSinceEpoch,
-      "topFrame": frameDesc(topFrame, 0),
+      "topFrame": await frameDesc(topFrame, 0),
       "atAsyncSuspension": false,
       // TODO(sigurdm): pass thrown as an instance.
     };
     streamNotify("Debug", event);
   }
 
   @override
   pauseExit(int processId, BackTraceFrame topFrame) {
     // TODO(sigurdm): implement pauseExit
   }
 
   @override
-  pauseInterrupted(int processId, BackTraceFrame topFrame) {
+  pauseInterrupted(int processId, BackTraceFrame topFrame) async {
     Map event = {
       "type": "Event",
       "kind": "PauseInterrupted",
       "isolate": isolateRef(processId),
       "timestamp": new DateTime.now().millisecondsSinceEpoch,
-      "topFrame": frameDesc(topFrame, 0),
+      "topFrame": await frameDesc(topFrame, 0),
       "atAsyncSuspension": false,
     };
     lastPauseEvent = event;
     streamNotify("Debug", event);
   }
 
   @override
   pauseStart(int processId) {
     Map event = {
       "type": "Event",
@@ skipping 31 matching lines @@
   processStart(int processId) {
     streamNotify("Isolate", {
       "type": "Event",
       "kind": "IsolateStart",
       "isolate": isolateRef(processId),
       "timestamp": new DateTime.now().millisecondsSinceEpoch,
     });
   }
 
   @override
-  resume(int processId) {
+  resume(int processId) async {
     Map event = {
       "type": "Event",
       "kind": "Resume",
       "isolate": isolateRef(processId),
       "timestamp": new DateTime.now().millisecondsSinceEpoch,
     };
     BackTraceFrame topFrame = vmContext.debugState.topFrame;
     if (topFrame != null) {
-      event["topFrame"] = frameDesc(vmContext.debugState.topFrame, 0);
+      event["topFrame"] = await frameDesc(vmContext.debugState.topFrame, 0);
     }
     lastPauseEvent = event;
     streamNotify("Debug", event);
   }
 
   @override
   writeStdErr(int processId, List<int> data) {
     Map event = {
       "type": "Event",
       "kind": "WriteEvent",
@@ skipping 41 matching lines @@
   }
 
   visitScopeContainerElement(ScopeContainerElement e, _) {
     e.forEachLocalMember(visit);
   }
 
   visitCompilationUnitElement(CompilationUnitElement e, _) {
     e.forEachLocalMember(visit);
   }
 }