Initial Implementation of the vm-service protocol

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 61 matching lines @@
 // TODO(sigurdm): for now only the stdio and stderr events are actually
 // notified.
 abstract class DebugListener {
   // Notification that a new process has started.
   processStart(int processId) {}
   // Notification that a process is ready to run.
   processRunnable(int processId) {}
   // Notification that a process has exited.
   processExit(int processId) {}
   // A process has paused at start, before executing code.
-  pauseStart(int processId, BackTraceFrame topframe) {}
+  // This is sent on spawning processes.
+  pauseStart(int processId) {}
   // An process has paused at exit, before terminating.
-  pauseExit(int processId, BackTraceFrame topframe) {}
+  pauseExit(int processId, BackTraceFrame topFrame) {}
   // A process has paused at a breakpoint or due to stepping.
-  pauseBreakpoint(int processId, BackTraceFrame topframe, int breakpointId) {}
+  pauseBreakpoint(
+      int processId, BackTraceFrame topFrame, Breakpoint breakpoint) {}
   // A process has paused due to interruption.
-  pauseInterrupted(int processId, BackTraceFrame topframe) {}
+  pauseInterrupted(int processId, BackTraceFrame topFrame) {}
   // A process has paused due to an exception.
-  pauseException(int processId, BackTraceFrame topframe, RemoteObject thrown) {}
+  pauseException(int processId, BackTraceFrame topFrame, RemoteObject thrown) {}
   // A process has started or resumed execution.
   resume(int processId) {}
   // A breakpoint has been added for a process.
   breakpointAdded(int processId, Breakpoint breakpoint) {}
   // A breakpoint has been removed.
   breakpointRemoved(int processId, Breakpoint breakpoint) {}
   // A garbage collection event.
   gc(int processId) {}
   // Notification of bytes written to stdout.
   writeStdOut(int processId, List<int> data) {}
   // Notification of bytes written stderr.
   writeStdErr(int processId, List<int> data) {}
   // The connection to the vm was lost.
   lostConnection() {}
+  // The debugged program is over.
+  terminated() {}
 }
 
 class SinkDebugListener extends DebugListener {
   final Sink stdoutSink;
   final Sink stderrSink;
   SinkDebugListener(this.stdoutSink, this.stderrSink);
 
   writeStdOut(int processId, List<int> data) {
     stdoutSink.add(data);
   }
@@ skipping 181 matching lines @@
     while (!_drainedIncomingCommands) {
       VmCommand response = await readNextCommand(force: false);
       if (!ignoreExtraCommands && response != null) {
         await kill();
         throw new StateError(
             "Got unexpected command from dartino-vm during shutdown "
                 "($response)");
       }
     }
     vmState = VmState.terminated;
+    listeners.forEach((DebugListener listener) {
+      listener.terminated();
+    });
     return connection.done;
   }
 
   Future interrupt() {
     return sendCommand(const ProcessDebugInterrupt());
   }
 
   /// Closes the connection to the dartino-vm. It does not wait until it shuts
   /// down.
   ///
@@ skipping 81 matching lines @@
     VmCommand reply = await runCommand(const Debugging());
     if (reply == null || reply is! DebuggingReply) {
       throw new Exception("Expected a reply from the debugging command");
     }
     return reply;
   }
 
   Future spawnProcess(List<String> arguments) async {
     await runCommand(new ProcessSpawnForMain(arguments));
     vmState = VmState.spawned;
+    listeners.forEach((DebugListener listener) {
+      listener.pauseStart(0);
+      listener.processRunnable(0);
+    });
   }
 
   /// Returns the [NameOffsetMapping] stored in the '.info.json' adjacent to a
   /// snapshot location.
   Future<NameOffsetMapping> getInfoFromSnapshotLocation(Uri snapshot) async {
     Uri info = snapshot.replace(path: "${snapshot.path}.info.json");
     File infoFile = new File.fromUri(info);
 
     if (!await infoFile.exists()) {
       await shutdown();
@@ skipping 78 matching lines @@
   // This method handles the various responses a command can return to indicate
   // the process has stopped running.
   // The session's state is updated to match the current state of the vm.
   Future<VmCommand> handleProcessStop(VmCommand response) async {
     interactiveExitCode = exit_codes.COMPILER_EXITCODE_CRASH;
     debugState.reset();
     switch (response.code) {
       case VmCommandCode.UncaughtException:
         interactiveExitCode = exit_codes.DART_VM_EXITCODE_UNCAUGHT_EXCEPTION;
         vmState = VmState.terminating;
+        UncaughtException command = response;
+        debugState.currentProcess = command.processId;
+        var function = dartinoSystem.lookupFunctionById(command.functionId);
+        debugState.topFrame = new BackTraceFrame(
+            function, command.bytecodeIndex, compiler, debugState);
+        RemoteObject thrown = await uncaughtException();
+        listeners.forEach((DebugListener listener) {
+          listener.pauseException(
+              debugState.currentProcess, debugState.topFrame, thrown);
+        });
         break;
 
       case VmCommandCode.ProcessCompileTimeError:
+        listeners.forEach((DebugListener listener) {
+          listener.pauseException(0, null, null); // XXX
+        });
         interactiveExitCode = exit_codes.DART_VM_EXITCODE_COMPILE_TIME_ERROR;
         vmState = VmState.terminating;
         break;
 
       case VmCommandCode.ProcessTerminated:
         interactiveExitCode = 0;
-        vmState = VmState.terminating;
+        listeners.forEach((DebugListener listener) {
+          listener.processExit(0); // XXX
+        });
         break;
 
       case VmCommandCode.ConnectionError:
         interactiveExitCode = exit_codes.COMPILER_EXITCODE_CONNECTION_ERROR;
         vmState = VmState.terminating;
         await shutdown();
+        listeners.forEach((DebugListener listener) {
+          listener.lostConnection();
+        });
         break;
 
       case VmCommandCode.ProcessBreakpoint:
         interactiveExitCode = 0;
         ProcessBreakpoint command = response;
         debugState.currentProcess = command.processId;
         var function = dartinoSystem.lookupFunctionById(command.functionId);
         debugState.topFrame = new BackTraceFrame(
             function, command.bytecodeIndex, compiler, debugState);
         vmState = VmState.paused;
+        Breakpoint bp = debugState.breakpoints[command.breakpointId];
+        if (bp == null) {
+          listeners.forEach((DebugListener listener) {
+            listener.pauseInterrupted(
+                command.processId,
+                debugState.topFrame);
+          });
+        } else {
+          listeners.forEach((DebugListener listener) {
+            listener.pauseBreakpoint(
+                command.processId,
+                debugState.topFrame,
+                bp);
+          });
+        }
         break;
 
       default:
         throw new StateError(
             "Unhandled response from Dartino VM connection: ${response.code}");
 
     }
     return response;
   }
 
   Future<VmCommand> startRunning() async {
     await sendCommand(const ProcessRun());
     vmState = VmState.running;
+    listeners.forEach((DebugListener listener) {
+      listener.processStart(0);
+    });
+    listeners.forEach((DebugListener listener) {
+      listener.processRunnable(0);
+    });
+    listeners.forEach((DebugListener listener) {
+      listener.resume(0);
+    });
     return handleProcessStop(await readNextCommand());
   }
 
-  Future setBreakpointHelper(String name,
-                             DartinoFunction function,
+  Future<Breakpoint> setBreakpointHelper(DartinoFunction function,
                              int bytecodeIndex) async {
     ProcessSetBreakpoint response = await runCommands([
         new PushFromMap(MapId.methods, function.functionId),
         new ProcessSetBreakpoint(bytecodeIndex),
     ]);
     int breakpointId = response.value;
-    var breakpoint = new Breakpoint(function, bytecodeIndex, breakpointId);
+    Breakpoint breakpoint =
+        new Breakpoint(function, bytecodeIndex, breakpointId);
     debugState.breakpoints[breakpointId] = breakpoint;
+    listeners.forEach(
+        (DebugListener listener) => listener.breakpointAdded(0, breakpoint));
     return breakpoint;
   }
 
   // TODO(ager): Let setBreakpoint return a stream instead and deal with
   // error situations such as bytecode indices that are out of bounds for
   // some of the methods with the given name.
   Future setBreakpoint({String methodName, int bytecodeIndex}) async {
     Iterable<DartinoFunction> functions =
         dartinoSystem.functionsWhere((f) => f.name == methodName);
     List<Breakpoint> breakpoints = [];
     for (DartinoFunction function in functions) {
       breakpoints.add(
-          await setBreakpointHelper(methodName, function, bytecodeIndex));
+          await setBreakpointHelper(function, bytecodeIndex));
     }
     return breakpoints;
   }
 
-  Future setFileBreakpointFromPosition(String name,
+  Future<Breakpoint> setFileBreakpointFromPosition(String name,
                                        Uri file,
                                        int position) async {
     if (position == null) {
       return null;
     }
     DebugInfo debugInfo = compiler.debugInfoForPosition(
         file,
         position,
         dartinoSystem);
     if (debugInfo == null) {
       return null;
     }
     SourceLocation location = debugInfo.locationForPosition(position);
     if (location == null) {
       return null;
     }
     DartinoFunction function = debugInfo.function;
     int bytecodeIndex = location.bytecodeIndex;
-    return setBreakpointHelper(function.name, function, bytecodeIndex);
+    return setBreakpointHelper(function, bytecodeIndex);
   }
 
-  Future setFileBreakpointFromPattern(Uri file,
+  Future<Breakpoint> setFileBreakpointFromPattern(Uri file,
                                       int line,
                                       String pattern) async {
     assert(line > 0);
     int position = compiler.positionInFileFromPattern(file, line - 1, pattern);
     return setFileBreakpointFromPosition(
         '$file:$line:$pattern', file, position);
   }
 
-  Future setFileBreakpoint(Uri file, int line, int column) async {
+  Future<Breakpoint> setFileBreakpoint(Uri file, int line, int column) async {
     assert(line > 0 && column > 0);
     int position = compiler.positionInFile(file, line - 1, column - 1);
     return setFileBreakpointFromPosition('$file:$line:$column', file, position);
   }
 
-  Future doDeleteOneShotBreakpoint(int processId, int breakpointId) async {
+  Future<Null> doDeleteOneShotBreakpoint(
+      int processId, int breakpointId) async {
     ProcessDeleteBreakpoint response = await runCommand(
         new ProcessDeleteOneShotBreakpoint(processId, breakpointId));
     assert(response.id == breakpointId);
   }
 
   Future<Breakpoint> deleteBreakpoint(int id) async {
+    assert(!isRunning && !isTerminated);
     if (!debugState.breakpoints.containsKey(id)) {
       return null;
     }
     ProcessDeleteBreakpoint response =
         await runCommand(new ProcessDeleteBreakpoint(id));
     assert(response.id == id);
-    return debugState.breakpoints.remove(id);
+    Breakpoint breakpoint = debugState.breakpoints.remove(id);
+    listeners.forEach((DebugListener listener) {
+      listener.breakpointRemoved(0, breakpoint);
+    });
+    return breakpoint;
   }
 
   List<Breakpoint> breakpoints() {
     assert(debugState.breakpoints != null);
     return debugState.breakpoints.values.toList();
   }
 
   Iterable<Uri> findSourceFiles(Pattern pattern) {
     return compiler.findSourceFiles(pattern);
   }
@@ skipping 102 matching lines @@
         response.breakpointId == setBreakpoint.value;
     if (!success && !isTerminated && setBreakpoint.value != -1) {
       // Delete the initial one-time breakpoint as it wasn't hit.
       await doDeleteOneShotBreakpoint(processId, setBreakpoint.value);
     }
     return response;
   }
 
   Future<VmCommand> cont() async {
     assert(isPaused);
+    listeners.forEach((DebugListener listener) {
+      listener.resume(0);
+    });
     return handleProcessStop(await runCommand(const ProcessContinue()));
   }
 
   bool selectFrame(int frame) {
     if (debugState.currentBackTrace == null ||
         debugState.currentBackTrace.actualFrameNumber(frame) == -1) {
       return false;
     }
     debugState.currentFrame = frame;
     return true;
@@ skipping 29 matching lines @@
       } else {
         assert(response is InstanceStructure);
         List<DartValue> fields = await readInstanceStructureFields(response);
         debugState.currentUncaughtException =
             new RemoteInstance(response, fields);
       }
     }
     return debugState.currentUncaughtException;
   }
 
-  Future<BackTrace> backTrace() async {
+  Future<BackTrace> backTrace({int processId}) async {
+    processId ??= debugState.currentProcess;
     assert(isSpawned);
     if (debugState.currentBackTrace == null) {
       ProcessBacktrace backtraceResponse =
           await runCommand(
-              new ProcessBacktraceRequest(debugState.currentProcess));
+              new ProcessBacktraceRequest(processId));
       debugState.currentBackTrace =
           stackTraceFromBacktraceResponse(backtraceResponse);
     }
     return debugState.currentBackTrace;
   }
 
   Future<BackTrace> backtraceForFiber(int fiber) async {
     ProcessBacktrace backtraceResponse =
         await runCommand(new ProcessFiberBacktraceRequest(fiber));
     return stackTraceFromBacktraceResponse(backtraceResponse);
   }
 
   Future<List<BackTrace>> fibers() async {
     assert(isRunning || isPaused);
     await runCommand(const NewMap(MapId.fibers));
     ProcessNumberOfStacks response =
         await runCommand(const ProcessAddFibersToMap());
     int numberOfFibers = response.value;
     List<BackTrace> stacktraces = new List(numberOfFibers);
     for (int i = 0; i < numberOfFibers; i++) {
       stacktraces[i] = await backtraceForFiber(i);
     }
     await runCommand(const DeleteMap(MapId.fibers));
     return stacktraces;
   }
 
   Future<List<int>> processes() async {
-    assert(isRunning || isPaused);
+    assert(isSpawned);
     ProcessGetProcessIdsResult response =
       await runCommand(const ProcessGetProcessIds());
     return response.ids;
   }
 
   Future<BackTrace> processStack(int processId) async {
     assert(isPaused);
     ProcessBacktrace backtraceResponse =
       await runCommand(new ProcessBacktraceRequest(processId));
     return stackTraceFromBacktraceResponse(backtraceResponse);
@@ skipping 170 matching lines @@
   }
 
   bool toggleInternal() {
     debugState.showInternalFrames = !debugState.showInternalFrames;
     if (debugState.currentBackTrace != null) {
       debugState.currentBackTrace.visibilityChanged();
     }
     return debugState.showInternalFrames;
   }
 }