Initial Implementation of the vm-service protocol

pkg/dartino_compiler/lib/src/verbs/debug_verb.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_compiler.verbs.debug_verb;
 
 import 'dart:core' hide
     StackTrace;
 
 import 'infrastructure.dart';
@@ skipping 27 matching lines @@
 import '../hub/client_commands.dart' show
     ClientCommandCode;
 
 import 'package:dartino_compiler/debug_state.dart' show
     Breakpoint;
 
 import '../../debug_state.dart' show
     RemoteObject,
     BackTrace;
 
+import '../debug_service_protocol.dart' show
+    DebugServer;
+
 import '../../vm_commands.dart' show
     VmCommand;
 
 import '../../cli_debugger.dart' show
     CommandLineDebugger;
 
 const Action debugAction =
     const Action(
         debug,
         debugDocumentation,
@@ skipping 10 matching lines @@
           TargetKind.FIBERS,
           TargetKind.FILE,
           TargetKind.FINISH,
           TargetKind.FRAME,
           TargetKind.LIST,
           TargetKind.LIST_BREAKPOINTS,
           TargetKind.PRINT,
           TargetKind.PRINT_ALL,
           TargetKind.RESTART,
           TargetKind.RUN_TO_MAIN,
+          TargetKind.SERVE,
           TargetKind.STEP,
           TargetKind.STEP_BYTECODE,
           TargetKind.STEP_OVER,
           TargetKind.STEP_OVER_BYTECODE,
           TargetKind.TOGGLE,
         ]);
 
 const int sigQuit = 3;
 
 Future debug(AnalyzedSentence sentence, VerbContext context) async {
@@ skipping 79 matching lines @@
       debugTask = new DebuggerTask(TargetKind.PRINT.index, base,
           argument: sentence.targetName);
       break;
     case TargetKind.PRINT_ALL:
       debugTask = new DebuggerTask(TargetKind.PRINT_ALL.index, base);
       break;
     case TargetKind.TOGGLE:
       debugTask = new DebuggerTask(TargetKind.TOGGLE.index, base,
           argument: sentence.targetName);
       break;
+    case TargetKind.SERVE:
+      debugTask = new DebuggerTask(TargetKind.SERVE.index, base,
+          argument: sentence.targetUri, snapshotLocation: sentence.withUri);
+      break;
     case TargetKind.FILE:
       debugTask = new DebuggerTask(TargetKind.FILE.index, base,
           argument: sentence.targetUri, snapshotLocation: sentence.withUri);
       break;
+
     default:
       throwInternalError("Unimplemented ${sentence.target}");
   }
 
   return context.performTaskInWorker(combineTasks(attachTask, debugTask));
 }
 
 // Returns a debug client event handler that is bound to the current session.
 ClientEventHandler debugClientEventHandler(
     SessionState state,
@@ skipping 78 matching lines @@
       true,
       () => interactiveDebuggerTask(
           state,
           base,
           stdinController,
           snapshotLocation: snapshotLocation),
       eventHandler:
           debugClientEventHandler(state, commandIterator, stdinController));
 }
 
+Future<int> serveDebuggerTask(
+    CommandSender commandSender,
+    StreamIterator<ClientCommand> commandIterator,
+    SessionState state,
+    Uri script,
+    Uri base,
+    {Uri snapshotLocation}) {
+
+  return compileAndAttachToVmThen(
+      commandSender,
+      commandIterator,
+      state,
+      script,
+      base,
+      true,
+      () => new DebugServer().serveSingleShot(
+          state, snapshotLocation: snapshotLocation));
+}
+
 Future<int> interactiveDebuggerTask(
     SessionState state,
     Uri base,
     StreamController stdinController,
     {Uri snapshotLocation}) async {
   DartinoVmContext vmContext = state.vmContext;
   if (vmContext == null) {
     throwFatalError(DiagnosticKind.attachToVmBeforeRun);
   }
   List<DartinoDelta> compilationResult = state.compilationResults;
@@ skipping 66 matching lines @@
       case TargetKind.STEP_OVER_BYTECODE:
         return stepOverBytecodeDebuggerTask(
             commandSender, SessionState.current);
       case TargetKind.PRINT:
         return printDebuggerTask(commandSender, SessionState.current, argument);
       case TargetKind.PRINT_ALL:
         return printAllDebuggerTask(commandSender, SessionState.current);
       case TargetKind.TOGGLE:
         return toggleDebuggerTask(
             commandSender, SessionState.current, argument);
+      case TargetKind.SERVE:
+        return serveDebuggerTask(
+            commandSender,
+            commandIterator,
+            SessionState.current,
+            argument,
+            base,
+            snapshotLocation: snapshotLocation);
       case TargetKind.FILE:
         return runInteractiveDebuggerTask(
             commandSender, commandIterator, SessionState.current, argument,
             base, snapshotLocation: snapshotLocation);
-
       default:
         throwInternalError("Unimplemented ${TargetKind.values[kind]}");
     }
     return null;
   }
 }
 
 DartinoVmContext attachToSession(
     SessionState state, CommandSender commandSender) {
   DartinoVmContext vmContext = state.vmContext;
@@ skipping 373 matching lines @@
 
   if (argument != 'internal') {
     // TODO(ager, lukechurch): Fix error reporting.
     throwInternalError("Invalid argument to toggle. "
                        "Valid arguments: 'internal'.");
   }
   await vmContext.toggleInternal();
 
   return 0;
 }