Implement rewind: drop one or more frames from the debugger.

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:svg';
 import 'dart:html';
 import 'dart:math';
@@ skipping 191 matching lines @@
       return new Future.value(null);
     }
     if (debugger.currentFrame == null) {
       debugger.console.print('No stack');
       return new Future.value(null);
     }
     try {
       debugger.downFrame(count);
       debugger.console.print('frame = ${debugger.currentFrame}');
     } catch (e) {
-      debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
+      debugger.console.print(
+          'frame must be in range [${e.start}..${e.end-1}]');
     }
     return new Future.value(null);
   }
 
   String helpShort = 'Move down one or more frames (hotkey: [Page Down])';
 
   String helpLong = 'Move down one or more frames.\n'
       '\n'
       'Hotkey: [Page Down]\n'
       '\n'
@@ skipping 13 matching lines @@
       return new Future.value(null);
     }
     if (debugger.currentFrame == null) {
       debugger.console.print('No stack');
       return new Future.value(null);
     }
     try {
       debugger.upFrame(count);
       debugger.console.print('frame = ${debugger.currentFrame}');
     } on RangeError catch (e) {
-      debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
+      debugger.console.print(
+          'frame must be in range [${e.start}..${e.end-1}]');
     }
     return new Future.value(null);
   }
 
   String helpShort = 'Move up one or more frames (hotkey: [Page Up])';
 
   String helpLong = 'Move up one or more frames.\n'
       '\n'
       'Hotkey: [Page Up]\n'
       '\n'
@@ skipping 15 matching lines @@
       return new Future.value(null);
     }
     if (debugger.currentFrame == null) {
       debugger.console.print('No stack');
       return new Future.value(null);
     }
     try {
       debugger.currentFrame = frame;
       debugger.console.print('frame = ${debugger.currentFrame}');
     } on RangeError catch (e) {
-      debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
+      debugger.console.print(
+          'frame must be in range [${e.start}..${e.end-1}]');
     }
     return new Future.value(null);
   }
 
   String helpShort = 'Set the current frame';
 
   String helpLong = 'Set the current frame.\n'
       '\n'
       'Syntax: frame <number>\n'
       '        f <count>\n';
@@ skipping 103 matching lines @@
 
   String helpLong =
       'Continue running the isolate until it reaches the next source '
       'location.\n'
       '\n'
       'Hotkey: [F10]\n'
       '\n'
       'Syntax: step\n';
 }
 
+class RewindCommand extends DebuggerCommand {
+  RewindCommand(Debugger debugger) : super(debugger, 'rewind', []);
+
+  Future run(List<String> args) async {
+    try {
+      int count = 1;
+      if (args.length == 1) {
+        count = int.parse(args[0]);
+      } else if (args.length > 1) {
+        debugger.console.print('rewind expects 0 or 1 argument');
+        return;
+      } else if (count < 1 || count > debugger.stackDepth) {
+        debugger.console.print(
+            'frame must be in range [1..${debugger.stackDepth - 1}]');
+        return;
+      }
+      await debugger.rewind(count);
+    } on S.ServerRpcException catch(e) {
+      if (e.code == S.ServerRpcException.kCannotResume) {
+        debugger.console.printRed(e.data['details']);
+      } else {
+        rethrow;
+      }
+    }
+  }
+
+  String helpShort = 'Rewind the stack to a previous frame';
+
+  String helpLong =
+      'Rewind the stack to a previous frame.\n'
+      '\n'
+      'Syntax: rewind\n'
+      '        rewind <count>\n';
+}
+
+class ReloadCommand extends DebuggerCommand {
+  ReloadCommand(Debugger debugger) : super(debugger, 'reload', []);
+
+  Future run(List<String> args) async {
+    try {
+      int count = 1;
+      if (args.length > 0) {
+        debugger.console.print('reload expects no arguments');
+        return;
+      }
+      await debugger.isolate.reloadSources();
+      // debugger.clearStack();
+      debugger.console.print('reload complete');
+      await debugger.refreshStack();
+    } on S.ServerRpcException catch(e) {
+      if (e.code == S.ServerRpcException.kIsolateReloadBarred ||
+          e.code == S.ServerRpcException.kIsolateReloadFailed ||
+          e.code == S.ServerRpcException.kIsolateIsReloading) {
+        debugger.console.printRed(e.data['details']);
+      } else {
+        rethrow;
+      }
+    }
+  }
+
+  String helpShort = 'Reload the sources for the current isolate';
+
+  String helpLong =
+      'Reload the sources for the current isolate.\n'
+      '\n'
+      'Syntax: reload\n';
+}
+
 class ClsCommand extends DebuggerCommand {
   ClsCommand(Debugger debugger) : super(debugger, 'cls', []) {}
 
   Future run(List<String> args) {
     debugger.console.clear();
     debugger.console.newline();
     return new Future.value(null);
   }
 
   String helpShort = 'Clear the console';
@@ skipping 240 matching lines @@
             debugger.console.print('Unable to set breakpoint at ${loc}');
           } else {
             rethrow;
           }
         }
       } else {
         assert(loc.script != null);
         var script = loc.script;
         await script.load();
         if (loc.line < 1 || loc.line > script.lines.length) {
-          debugger.console
-              .print('line number must be in range [1,${script.lines.length}]');
+          debugger.console.print(
+              'line number must be in range [1..${script.lines.length}]');
           return;
         }
         try {
           await debugger.isolate.addBreakpoint(script, loc.line, loc.col);
         } on S.ServerRpcException catch (e) {
           if (e.code == S.ServerRpcException.kCannotAddBreakpoint) {
             debugger.console.print('Unable to set breakpoint at ${loc}');
           } else {
             rethrow;
           }
@@ skipping 59 matching lines @@
     }
     if (loc.function != null) {
       debugger.console.print('Ignoring breakpoint at $loc: '
           'Clearing function breakpoints not yet implemented');
       return;
     }
 
     var script = loc.script;
     if (loc.line < 1 || loc.line > script.lines.length) {
       debugger.console
-          .print('line number must be in range [1,${script.lines.length}]');
+          .print('line number must be in range [1..${script.lines.length}]');
       return;
     }
     var lineInfo = script.getLine(loc.line);
     var bpts = lineInfo.breakpoints;
     var foundBreakpoint = false;
     if (bpts != null) {
       var bptList = bpts.toList();
       for (var bpt in bptList) {
         if (loc.col == null ||
             loc.col == script.tokenToCol(bpt.location.tokenPos)) {
@@ skipping 134 matching lines @@
   String helpLong = 'Show current frame.\n'
       '\n'
       'Syntax: info frame\n';
 }
 
 class IsolateCommand extends DebuggerCommand {
   IsolateCommand(Debugger debugger)
       : super(debugger, 'isolate', [
           new IsolateListCommand(debugger),
           new IsolateNameCommand(debugger),
-          new IsolateReloadCommand(debugger),
         ]) {
     alias = 'i';
   }
 
   Future run(List<String> args) {
     if (args.length != 1) {
       debugger.console.print('isolate expects one argument');
       return new Future.value(null);
     }
     var arg = args[0].trim();
@@ skipping 122 matching lines @@
     return debugger.isolate.setName(args[0]);
   }
 
   String helpShort = 'Rename the current isolate';
 
   String helpLong = 'Rename the current isolate.\n'
       '\n'
       'Syntax: isolate name <name>\n';
 }
 
-class IsolateReloadCommand extends DebuggerCommand {
-  IsolateReloadCommand(Debugger debugger) : super(debugger, 'reload', []);
-
-  Future run(List<String> args) async {
-    if (debugger.isolate == null) {
-      debugger.console.print('There is no current vm');
-      return;
-    }
-
-    await debugger.isolate.reloadSources();
-
-    debugger.console.print('Isolate reloading....');
-  }
-
-  String helpShort = 'Reload the sources for the current isolate.';
-
-  String helpLong = 'Reload the sources for the current isolate.\n'
-      '\n'
-      'Syntax: reload\n';
-}
-
 class InfoCommand extends DebuggerCommand {
   InfoCommand(Debugger debugger)
       : super(debugger, 'info', [
           new InfoBreakpointsCommand(debugger),
           new InfoFrameCommand(debugger)
         ]);
 
   Future run(List<String> args) {
     debugger.console.print("'info' expects a subcommand (see 'help info')");
     return new Future.value(null);
@@ skipping 288 matching lines @@
       new DeleteCommand(this),
       new DownCommand(this),
       new FinishCommand(this),
       new FrameCommand(this),
       new HelpCommand(this),
       new InfoCommand(this),
       new IsolateCommand(this),
       new LogCommand(this),
       new PauseCommand(this),
       new PrintCommand(this),
+      new ReloadCommand(this),
       new RefreshCommand(this),
+      new RewindCommand(this),
       new SetCommand(this),
       new SmartNextCommand(this),
       new StepCommand(this),
       new SyncNextCommand(this),
       new UpCommand(this),
       new VmCommand(this),
     ], _history);
     _consolePrinter = new _ConsoleStreamPrinter(this);
   }
 
@@ skipping 64 matching lines @@
 
   void warnOutOfDate() {
     // Wait a bit, then tell the user that the stack may be out of date.
     new Timer(const Duration(seconds: 2), () {
       if (!isolatePaused()) {
         stackElement.isSampled = true;
       }
     });
   }
 
+  void clearStack() {
+    stackElement.clearStack();
+  }
+
   Future<S.ServiceMap> _refreshStack(M.DebugEvent pauseEvent) {
     return isolate.getStack().then((result) {
       if (result.isSentinel) {
         // The isolate has gone away.  The IsolateExit event will
         // clear the isolate for the debugger page.
         return;
       }
       stack = result;
       stackElement.updateStack(stack, pauseEvent);
       if (stack['frames'].length > 0) {
@@ skipping 403 matching lines @@
       if (event is M.PauseExitEvent) {
         console.print("Type 'continue' [F7] to exit the isolate");
         return new Future.value(null);
       }
       return isolate.stepInto();
     } else {
       console.print('The program is already running');
       return new Future.value(null);
     }
   }
+
+  Future rewind(int count) {
+    if (isolatePaused()) {
+      var event = isolate.pauseEvent;
+      if (event is M.PauseExitEvent) {
+        console.print("Type 'continue' [F7] to exit the isolate");
+        return new Future.value(null);
+      }
+      return isolate.rewind(count);
+    } else {
+      console.print('The program must be paused');
+      return new Future.value(null);
+    }
+  }
 }
 
 class DebuggerPageElement extends HtmlElement implements Renderable {
   static const tag =
       const Tag<DebuggerPageElement>('debugger-page', dependencies: const [
     NavTopMenuElement.tag,
     NavVMMenuElement.tag,
     NavIsolateMenuElement.tag,
     NavNotifyElement.tag,
   ]);
@@ skipping 374 matching lines @@
 
     hasMessages = messageElements.isNotEmpty;
   }
 
   void updateStack(S.ServiceMap newStack, M.DebugEvent pauseEvent) {
     updateStackFrames(newStack);
     updateStackMessages(newStack);
     isSampled = pauseEvent == null;
   }
 
+  void clearStack() {
+    List frameElements = _frameList.children;

[Cutch, 2016/11/22 22:27:50]

can we not just call clear on the lists?

[turnidge, 2016/11/22 22:54:06]

Turns out this code was dead.  Removed.

+    for (int i = 0; i < frameElements.length; i++) {
+      frameElements.removeAt(0);
+    }
+    List messageElements = _messageList.children;
+    for (int i = 0; i < messageElements.length; i++) {
+      messageElements.removeAt(0);
+    }
+  }
+
   void setCurrentFrame(int value) {
     currentFrame = value;
     List frameElements = _frameList.children;
     for (var frameElement in frameElements) {
       DebuggerFrameElement dbgFrameElement = frameElement.children[0];
       if (dbgFrameElement.frame.index == currentFrame) {
         dbgFrameElement.setCurrent(true);
       } else {
         dbgFrameElement.setCurrent(false);
       }
@@ skipping 220 matching lines @@
         ..classes = ['frameSummary']
         ..children = content
     ];
   }
 
   String makeExpandKey(String key) {
     return '${_frame.function.qualifiedName}/${key}';
   }
 
   bool matchFrame(S.Frame newFrame) {
-    return newFrame.function.id == _frame.function.id;
+    return (newFrame.function.id == _frame.function.id &&
+            newFrame.location.script.id ==
+            frame.location.script.id);
   }
 
   void updateFrame(S.Frame newFrame) {
     assert(matchFrame(newFrame));
     _frame = newFrame;
   }
 
   S.Script get script => _frame.location.script;
 
   int _varsTop(varsDiv) {
@@ skipping 663 matching lines @@
   ..setAttribute('height', '24')
   ..children = [
     new PathElement()
       ..setAttribute(
           'd',
           'M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 '
           '10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 '
           '0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 '
           '9h2V7h-2v2z')
   ];