Automagically change the meaning of 'next' to 'async-next' when paused at an async function at awai…

runtime/observatory/lib/src/elements/debugger.dart

 // Copyright (c) 2014, the Dart 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 file.
 
 library debugger_page_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
 import 'package:observatory/app.dart';
@@ skipping 299 matching lines @@
 
   String helpLong =
       'Continue running the isolate.\n'
       '\n'
       'Hotkey: [F7]\n'
       '\n'
       'Syntax: continue\n'
       '        c\n';
 }
 
-class NextCommand extends DebuggerCommand {
-  NextCommand(Debugger debugger) : super(debugger, 'next', []);
+class SmartNextCommand extends DebuggerCommand {
+  SmartNextCommand(Debugger debugger) : super(debugger, 'next', []) {
+    alias = 'n';
+  }
 
-  Future run(List<String> args) {
-    return debugger.next();
+  Future run(List<String> args) async {
+    return debugger.smartNext();
   }
 
   String helpShort =
       'Continue running the isolate until it reaches the next source location '
       'in the current function (hotkey: [F9])';
 
   String helpLong =
       'Continue running the isolate until it reaches the next source location '
       'in the current function.\n'
       '\n'
       'Hotkey: [F9]\n'
       '\n'
       'Syntax: next\n';
 }
 
+class SyncNextCommand extends DebuggerCommand {
+  SyncNextCommand(Debugger debugger) : super(debugger, 'next-sync', []);
+
+  Future run(List<String> args) {
+    return debugger.syncNext();
+  }
+
+  String helpShort =
+      'Run until return/unwind to current activation.';
+
+  String helpLong =
+      'Continue running the isolate until control returns to the current '
+      'activation or one of its callers.\n'
+      '\n'
+      'Syntax: next-sync\n';
+}
+
+class AsyncNextCommand extends DebuggerCommand {
+  AsyncNextCommand(Debugger debugger) : super(debugger, 'next-async', []);
+
+  Future run(List<String> args) {
+    return debugger.asyncNext();
+  }
+
+  String helpShort =
+      'Step over await or yield';
+
+  String helpLong =
+      'Continue running the isolate until control returns to the current '
+      'activation of an async or async* function.\n'
+      '\n'
+      'Syntax: next-async\n';
+}
+
 class StepCommand extends DebuggerCommand {
   StepCommand(Debugger debugger) : super(debugger, 'step', []) {
     alias = 's';
   }
 
   Future run(List<String> args) {
     return debugger.step();
   }
 
   String helpShort =
@@ skipping 88 matching lines @@
       'Syntax: log          '
       '# Display the current minimum log level.\n'
       '        log <level>  '
       '# Set the minimum log level to <level>.\n'
       '        log OFF      '
       '# Display no log messages.\n'
       '        log ALL      '
       '# Display all log messages.\n';
 }
 
-class AsyncNextCommand extends DebuggerCommand {
-  AsyncNextCommand(Debugger debugger) : super(debugger, 'anext', []) {
-  }
-
-  Future run(List<String> args) async {
-    if (debugger.isolatePaused()) {
-      var event = debugger.isolate.pauseEvent;
-      if (event.asyncContinuation == null) {
-        debugger.console.print("No async continuation at this location");
-      } else {
-        return debugger.isolate.asyncStepOver()[Isolate.kFirstResume];
-      }
-    } else {
-      debugger.console.print('The program is already running');
-    }
-  }
-
-  String helpShort =
-      'Step over await or yield';
-
-  String helpLong =
-      'Continue running the isolate until control returns to the current '
-      'activation of an async or async* function.\n'
-      '\n'
-      'Syntax: anext\n';
-}
-
 class FinishCommand extends DebuggerCommand {
   FinishCommand(Debugger debugger) : super(debugger, 'finish', []);
 
   Future run(List<String> args) {
     if (debugger.isolatePaused()) {
       var event = debugger.isolate.pauseEvent;
       if (event.kind == ServiceEvent.kPauseStart) {
         debugger.console.print(
             "Type 'continue' [F7] or 'step' [F10] to start the isolate");
         return new Future.value(null);
@@ skipping 713 matching lines @@
     } else {
       currentFrame += count;
     }
   }
 
   int get stackDepth => stack['frames'].length;
 
   ObservatoryDebugger() {
     _loadSettings();
     cmd = new RootCommand([
+        new AsyncNextCommand(this),
+        new BreakCommand(this),
+        new ClearCommand(this),
+        new ClsCommand(this),
+        new ContinueCommand(this),
+        new DeleteCommand(this),
+        new DownCommand(this),
+        new FinishCommand(this),
+        new FrameCommand(this),
         new HelpCommand(this),
-        new PrintCommand(this),
-        new DownCommand(this),
-        new UpCommand(this),
-        new FrameCommand(this),
-        new PauseCommand(this),
-        new ContinueCommand(this),
-        new NextCommand(this),
-        new StepCommand(this),
-        new AsyncNextCommand(this),
-        new FinishCommand(this),
-        new BreakCommand(this),
-        new SetCommand(this),
-        new ClearCommand(this),
-        new DeleteCommand(this),
         new InfoCommand(this),
         new IsolateCommand(this),
+        new LogCommand(this),
+        new PauseCommand(this),
+        new PrintCommand(this),
         new RefreshCommand(this),
-        new LogCommand(this),
-        new ClsCommand(this),
+        new SetCommand(this),
+        new SmartNextCommand(this),
+        new StepCommand(this),
+        new SyncNextCommand(this),
+        new UpCommand(this),
     ]);
     _consolePrinter = new _ConsoleStreamPrinter(this);
   }
 
   void _loadSettings() {
     _upIsDown = settings.get('up-is-down');
   }
 
   VM get vm => page.app.vm;
 
@@ skipping 129 matching lines @@
         } else if (event.exception != null) {
           console.print('Paused due to exception at '
                         '${script.name}:${line}:${col}');
           // This seems to be missing if we are paused-at-exception after
           // paused-at-isolate-exit. Maybe we shutdown part of the debugger too
           // soon?
           console.printRef(event.exception);
         } else {
           console.print('Paused at ${script.name}:${line}:${col}');
         }
-        if (event.asyncContinuation != null) {
-          console.print("Paused in async function: 'anext' available");
-        }
       });
     }
   }
 
   Future _reportBreakpointEvent(ServiceEvent event) {
     var bpt = event.breakpoint;
     var verb = null;
     switch (event.kind) {
       case ServiceEvent.kBreakpointAdded:
         verb = 'added';
@@ skipping 221 matching lines @@
         var pending = [];
         for (var bpt in bpts) {
           pending.add(isolate.removeBreakpoint(bpt));
         }
         await Future.wait(pending);
       }
     }
     return new Future.value(null);
   }
 
-  Future next() {
+
+  Future smartNext() async {
+    if (isolatePaused()) {
+      var event = isolate.pauseEvent;
+      if (event.atAsyncJump) {
+        return asyncNext();
+      } else {
+        return syncNext();
+      }
+    } else {
+      console.print('The program is already running');
+    }
+  }
+
+  Future asyncNext() async {
+    if (isolatePaused()) {
+      var event = isolate.pauseEvent;
+      if (event.asyncContinuation == null) {
+        console.print("No async continuation at this location");
+      } else {
+        return isolate.asyncStepOver()[Isolate.kFirstResume];
+      }
+    } else {
+      console.print('The program is already running');
+    }
+  }
+
+  Future syncNext() async {
     if (isolatePaused()) {
       var event = isolate.pauseEvent;
       if (event.kind == ServiceEvent.kPauseStart) {
         console.print("Type 'continue' [F7] or 'step' [F10] to start the isolate");
-        return new Future.value(null);
+        return;
       }
       if (event.kind == ServiceEvent.kPauseExit) {
         console.print("Type 'continue' [F7] to exit the isolate");
-        return new Future.value(null);
+        return;
       }
       return isolate.stepOver();
     } else {
       console.print('The program is already running');
-      return new Future.value(null);
+      return;
     }
   }
 
   Future step() {
     if (isolatePaused()) {
       var event = isolate.pauseEvent;
       if (event.kind == ServiceEvent.kPauseExit) {
         console.print("Type 'continue' [F7] to exit the isolate");
         return new Future.value(null);
       }
@@ skipping 634 matching lines @@
 
           case KeyCode.F8:
             e.preventDefault();
             debugger.toggleBreakpoint().whenComplete(() {
               busy = false;
             });
             break;
 
           case KeyCode.F9:
             e.preventDefault();
-            debugger.next().whenComplete(() {
+            debugger.smartNext().whenComplete(() {
               busy = false;
             });
             break;
 
           case KeyCode.F10:
             e.preventDefault();
             debugger.step().whenComplete(() {
               busy = false;
             });
             break;
@@ skipping 16 matching lines @@
         }
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }