Revert "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.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 487 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 614 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 &&
-            newFrame.location.script.id ==
-            frame.location.script.id);
+    return newFrame.function.id == _frame.function.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')
   ];