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 66 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 81 matching lines @@
             new StreamIterator<Pair<int, ByteData>>(connection.input.transform(
                 new SessionCommandTransformerBuilder().build())) {
     connection.done.catchError((_, __) {}).then((_) {
       vmState = VmState.terminated;
     });
 
     // TODO(ajohnsen): Should only be initialized on debug()/testDebugger().
     debugState = new DebugState(this);
   }
 
+  void notifyListeners(void f(DebugListener listener)) {
+    listeners.forEach(f);
+  }
+
   /// Convenience around [runCommands] for running just a single command.
   Future<VmCommand> runCommand(VmCommand command) {
     return runCommands([command]);
   }
 
   /// Sends the given commands to a dartino-vm and reads response commands
   /// (if necessary).
   ///
   /// If all commands have been successfully applied and responses been awaited,
   /// this function will complete with the last received [VmCommand] from the
@@ skipping 47 matching lines @@
 
       Pair<int, ByteData> c = _commandIterator.current;
 
       if (c == null) return null;
 
       VmCommand command = new VmCommand.fromBuffer(
           VmCommandCode.values[c.fst], toUint8ListView(c.snd),
           translateFunctionMessage,
           translateClassMessage);
       if (command is StdoutData) {
-        listeners.forEach((DebugListener listener) {
+        notifyListeners((DebugListener listener) {
           listener.writeStdOut(0, command.value);
         });
       } else if (command is StderrData) {
-        listeners.forEach((DebugListener listener) {
+        notifyListeners((DebugListener listener) {
           listener.writeStdErr(0, command.value);
         });
       } else {
         result = command;
       }
 
     }
     return result;
   }
 
   /// Closes the connection to the dartino-vm and drains the remaining response
   /// commands.
   ///
   /// If [ignoreExtraCommands] is `false` it will throw a StateError if the
   /// dartino-vm sent any commands.
   Future shutdown({bool ignoreExtraCommands: false}) async {
     await connection.close().catchError((_) {});
 
     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;
+    notifyListeners((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;
+    notifyListeners((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();
+        notifyListeners((DebugListener listener) {
+          listener.pauseException(
+              debugState.currentProcess, debugState.topFrame, thrown);
+        });
         break;
 
       case VmCommandCode.ProcessCompileTimeError:
+        notifyListeners((DebugListener listener) {
+          // TODO(sigurdm): Add processId and exception data.
+          listener.pauseException(0, null, null);
+        });
         interactiveExitCode = exit_codes.DART_VM_EXITCODE_COMPILE_TIME_ERROR;
         vmState = VmState.terminating;
         break;
 
       case VmCommandCode.ProcessTerminated:
         interactiveExitCode = 0;
         vmState = VmState.terminating;
+        notifyListeners((DebugListener listener) {
+          // TODO(sigurdm): Communicate process id.
+          listener.processExit(0);
+        });
         break;
 
       case VmCommandCode.ConnectionError:
         interactiveExitCode = exit_codes.COMPILER_EXITCODE_CONNECTION_ERROR;
         vmState = VmState.terminating;
         await shutdown();
+        notifyListeners((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) {
+          notifyListeners((DebugListener listener) {
+            listener.pauseInterrupted(
+                command.processId,
+                debugState.topFrame);
+          });
+        } else {
+          notifyListeners((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;
+    notifyListeners((DebugListener listener) {
+      listener.processStart(0);
+    });
+    notifyListeners((DebugListener listener) {
+      listener.processRunnable(0);
+    });
+    notifyListeners((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;
+    notifyListeners(
+        (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);
+    notifyListeners((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);
+    notifyListeners((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 213 matching lines @@
   }
 
   bool toggleInternal() {
     debugState.showInternalFrames = !debugState.showInternalFrames;
     if (debugState.currentBackTrace != null) {
       debugState.currentBackTrace.visibilityChanged();
     }
     return debugState.showInternalFrames;
   }
 }