Support for accessing arrays in the debugger

pkg/dartino_compiler/lib/vm_context.dart

 // Copyright (c) 2015, 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.
 
 library dartino.vm_session;
 
 import 'dart:async';
 
 import 'dart:typed_data' show
     ByteData;
@@ skipping 45 matching lines @@
 
 import 'src/vm_connection.dart' show
     VmConnection;
 
 import 'program_info.dart' show
     IdOffsetMapping,
     NameOffsetMapping,
     ProgramInfoJson;
 
 import 'package:compiler/src/elements/elements.dart' show
-    ClassElement,
-    FieldElement;
+    ClassElement;
 
 class SessionCommandTransformerBuilder
     extends CommandTransformerBuilder<Pair<int, ByteData>> {
 
   Pair<int, ByteData> makeCommand(int code, ByteData payload) {
     return new Pair<int, ByteData>(code, payload);
   }
 }
 
 // TODO(sigurdm): for now only the stdio and stderr events are actually
@@ skipping 771 matching lines @@
                          compiler,
                          debugState));
     }
     return stackTrace;
   }
 
   Future<RemoteObject> uncaughtException() async {
     assert(vmState == VmState.terminating);
     if (debugState.currentUncaughtException == null) {
       await sendCommand(const ProcessUncaughtExceptionRequest());
-      VmCommand response = await readNextCommand();
-      if (response is DartValue) {
-        debugState.currentUncaughtException = new RemoteValue(response);
-      } else {
-        assert(response is InstanceStructure);
-        List<DartValue> fields = await readInstanceStructureFields(response);
-        debugState.currentUncaughtException =
-            new RemoteInstance(response, fields);
-      }
+      debugState.currentUncaughtException = await readStructuredObject();
     }
     return debugState.currentUncaughtException;
   }
 
   Future<BackTrace> backTrace({int processId}) async {
     processId ??= debugState.currentProcess;
     assert(isSpawned);
     if (debugState.currentBackTrace == null) {
       ProcessBacktrace backtraceResponse =
           await runCommand(
@@ skipping 66 matching lines @@
       String fieldName = debugState.lookupFieldName(klass, i);
       if (fieldName == null) {
         fieldName = '<unnamed>';
       }
       sb.writeln('  $fieldName: ${dartValueToString(value)}');
     }
     sb.write('}');
     return '$sb';
   }
 
+  String arrayStructureToString(List<DartValue> items) {
+    StringBuffer sb = new StringBuffer();
+    sb.writeln("Array with length ${items.length} [");
+    for (int i = 0; i < items.length; i++) {
+      sb.writeln("  $i = ${dartValueToString(items[i])}");
+    }
+    sb.write("]");
+    return '$sb';
+  }
+
   String noSuchMethodErrorToString(List<DartValue> nsmFields) {
     assert(nsmFields.length == 3);
     ClassValue receiverClass = nsmFields[1];
     Integer receiverSelector = nsmFields[2];
     DartinoSelector selector = new DartinoSelector(receiverSelector.value);
 
     String method =
         dartinoSystem.lookupSymbolBySelector(selector.encodedSelector);
     DartinoClass klass = dartinoSystem.lookupClassById(receiverClass.classId);
     // TODO(ahe): If DartinoClass is a synthetic closure class, improve the
@@ skipping 13 matching lines @@
       case SelectorKind.Getter:
         return "NoSuchMethodError: "
             "Class '$name' has no getter named '$method'$raw";
 
       case SelectorKind.Setter:
         return "NoSuchMethodError: "
             "Class '$name' has no setter named '$method'$raw";
     }
   }
 
-  Future<List<DartValue>> readInstanceStructureFields(
-      InstanceStructure structure) async {
-    List<DartValue> fields = <DartValue>[];
-    for (int i = 0; i < structure.fields; i++) {
-      fields.add(await readNextCommand());
+  Future<RemoteObject> readStructuredObject() async {
+    VmCommand response = await readNextCommand();
+    if (response is DartValue) {
+      return new RemoteValue(response);
+    } else if (response is InstanceStructure) {
+      List<DartValue> fields = new List<DartValue>();
+      for (int i = 0; i < response.fields; i++) {
+        fields.add(await readNextCommand());
+      }
+      return new RemoteInstance(response, fields);
+    } else if (response is ArrayStructure) {
+      List<DartValue> values = new List<DartValue>();
+      for (int i = 0; i < response.length; i++) {
+        values.add(await readNextCommand());
+      }
+      return new RemoteArray(response, values);
+    } else {
+      return new RemoteErrorObject("Failed reading structured object.");
     }
-    return fields;
   }
 
   String exceptionToString(RemoteObject exception) {
     String message;
     if (exception is RemoteValue) {
       message = dartValueToString(exception.value);
     } else if (exception is RemoteInstance) {
       InstanceStructure structure = exception.instance;
       int classId = structure.classId;
       DartinoClass klass = dartinoSystem.lookupClassById(classId);
@@ skipping 12 matching lines @@
       throw new UnimplementedError();
     }
     return 'Uncaught exception: $message';
   }
 
   Future<RemoteObject> _processVariable(
       List<String> names, bool getStructure) async {
     assert(isSpawned);
     assert(names.isNotEmpty);
     String localName = names.first;
+    int frame = debugState.currentFrame;
     LocalValue local = await lookupValue(localName);
     if (local == null) {
       return new RemoteErrorObject("No local '$localName' in scope.");
     }
 
     List<int> fieldIndices = new List<int>();
     List<String> namesTillHere = <String>[localName];
     for (String fieldName in names.skip(1)) {
-      RemoteValue remoteValue =
-          await processLocal(local, fieldAccesses: fieldIndices);
+      RemoteValue remoteValue = await processLocal(
+          frame,
+          local.slot,
+          fieldAccesses: fieldIndices);
       DartValue value = remoteValue.value;
       if (value is Instance) {
         ClassElement classElement =
             dartinoSystem.classesById[value.classId].element;
         int fieldIndex = getFieldIndex(classElement, fieldName);
         if (fieldIndex == null) {
           return new RemoteErrorObject(
               "'${namesTillHere.join(".")}' has type ${classElement}"
               " that does not have a field named '${fieldName}'.");
         }
         fieldIndices.add(fieldIndex);
+      } else if (value is Array) {
+        int index = int.parse(fieldName, onError: (_) => -1);
+        if (index < 0 || index > value.length) {
+          return new RemoteErrorObject(
+              "${namesTillHere.join(".")}' is an array with length "
+              "${value.length}. It cannot be indexed with ${fieldName}");
+        }
+        fieldIndices.add(index);
       } else {
         return new RemoteErrorObject("'${namesTillHere.join(".")}' "
             "is a primitive value '${dartValueToString(value)}' "
             "and does not have a field named '${fieldName}'");
       }
       namesTillHere.add(fieldName);
     }
     if (getStructure) {
-      return await processLocalStructure(local, fieldAccesses: fieldIndices);
+      return await processLocalStructure(
+          frame, local.slot, fieldAccesses: fieldIndices);
     } else {
-      return await processLocal(local, fieldAccesses: fieldIndices);
+      return await processLocal(frame, local.slot, fieldAccesses: fieldIndices);
     }
   }
 
   Future<RemoteValue> processVariable(List<String> names) {
     return _processVariable(names, false);
   }
 
   Future<RemoteObject> processVariableStructure(List<String> names) {
     return _processVariable(names, true);
   }
 
   Future<List<RemoteObject>> processAllVariables() async {
     assert(isSpawned);
     BackTrace trace = await backTrace();
     ScopeInfo info = trace.scopeInfoForCurrentFrame;
     List<RemoteObject> variables = [];
     for (ScopeInfo current = info;
          current != ScopeInfo.sentinel;
          current = current.previous) {
-      variables.add(await processLocal(current.local, name: current.name));
+      variables.add(await processLocal(
+          debugState.currentFrame, current.local.slot, name: current.name));
     }
     return variables;
   }
 
   Future<LocalValue> lookupValue(String name) async {
     assert(isSpawned);
     BackTrace trace = await backTrace();
     return trace.scopeInfoForCurrentFrame.lookup(name);
   }
 
   Future<RemoteValue> processLocal(
-      LocalValue local,
+      int frameNumber,
+      int localSlot,
       {String name,
        List<int> fieldAccesses: const <int>[]}) async {
-    var actualFrameNumber = debugState.actualCurrentFrameNumber;
     VmCommand response = await runCommand(
-        new ProcessInstance(actualFrameNumber, local.slot, fieldAccesses));
+        new ProcessInstance(frameNumber, localSlot, fieldAccesses));
     assert(response is DartValue);
     return new RemoteValue(response, name: name);
   }
 
   Future<RemoteObject> processLocalStructure(
-      LocalValue local,
+      int frameNumber,
+      int localSlot,
       {String name,
        List<int> fieldAccesses: const <int>[]}) async {
-    var frameNumber = debugState.actualCurrentFrameNumber;
+    frameNumber ??= debugState.actualCurrentFrameNumber;
     await sendCommand(
-        new ProcessInstanceStructure(frameNumber, local.slot, fieldAccesses));
-    VmCommand response = await readNextCommand();
-    if (response is DartValue) {
-      return new RemoteValue(response);
-    } else {
-      assert(response is InstanceStructure);
-      List<DartValue> fields = await readInstanceStructureFields(response);
-      return new RemoteInstance(response, fields);
-    }
+        new ProcessInstanceStructure(frameNumber, localSlot, fieldAccesses));
+    return await readStructuredObject();
   }
 
   String remoteObjectToString(RemoteObject object) {
     String message;
     if (object is RemoteValue) {
       message = dartValueToString(object.value);
     } else if (object is RemoteInstance) {
       message = instanceStructureToString(object.instance, object.fields);
+    } else if (object is RemoteArray) {
+      message = arrayStructureToString(object.values);
     } else {
       throw new UnimplementedError();
     }
     if (object.name != null) {
       // Prefix with name.
       message = "${object.name}: $message";
     }
     return message;
   }
 
   bool toggleInternal() {
     debugState.showInternalFrames = !debugState.showInternalFrames;
     if (debugState.currentBackTrace != null) {
       debugState.currentBackTrace.visibilityChanged();
     }
     return debugState.showInternalFrames;
   }
 }