Add 'break' and 'clear' commands to Observatory 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:html';
 import 'observatory_element.dart';
 import 'package:observatory/cli.dart';
+import 'package:observatory/debugger.dart';
 import 'package:observatory/service.dart';
 import 'package:polymer/polymer.dart';
 
-// TODO(turnidge): Move Debugger, DebuggerCommand to their own lib.
+// TODO(turnidge): Move Debugger, DebuggerCommand to debugger library.
 abstract class DebuggerCommand extends Command {
-  Debugger debugger;
+  ObservatoryDebugger debugger;
 
   DebuggerCommand(this.debugger, name, children)
       : super(name, children);
 }
 
 class HelpCommand extends DebuggerCommand {
   HelpCommand(Debugger debugger) : super(debugger, 'help', []);
 
   Future run(List<String> args) {
     var con = debugger.console;
     con.printLine('List of commands:');
     con.newline();
 
     // TODO(turnidge): Build a real help system.
-    List completions = debugger.cmd.completeCommand('');
-    completions = completions.map((s )=> s.trimRight()).toList();
-    completions.sort();
-    con.printLine(completions.toString());
-    con.newline();
-    con.printLine("Command prefixes are accepted (e.g. 'h' for 'help')");
-    con.printLine("Hit [TAB] to complete a command (try 'i[TAB][TAB]')");
-    con.printLine("Hit [ENTER] to repeat the last command");
-
-    return new Future.value(null);
+    return debugger.cmd.completeCommand('').then((completions) {
+      completions = completions.map((s) => s.trimRight()).toList();
+      completions.sort();
+      con.printLine(completions.toString());
+      con.newline();
+      con.printLine("Command prefixes are accepted (e.g. 'h' for 'help')");
+      con.printLine("Hit [TAB] to complete a command (try 'i[TAB][TAB]')");
+      con.printLine("Hit [ENTER] to repeat the last command");
+    });
   }
 }
 
 class PauseCommand extends DebuggerCommand {
   PauseCommand(Debugger debugger) : super(debugger, 'pause', []);
 
   Future run(List<String> args) {
     if (!debugger.isolatePaused()) {
       return debugger.isolate.pause();
     } else {
@@ skipping 68 matching lines @@
   Future run(List<String> args) {
     if (debugger.isolatePaused()) {
       return debugger.isolate.stepOut();
     } else {
       debugger.console.printLine('The program is already running');
       return new Future.value(null);
     }
   }
 }
 
+class BreakCommand extends DebuggerCommand {
+  BreakCommand(Debugger debugger) : super(debugger, 'break', []);
+
+  Future run(List<String> args) {
+    if (args.length > 1) {
+      debugger.console.printLine('not implemented');
+      return new Future.value(null);
+    }
+    var arg = (args.length == 0 ? '' : args[0]);
+    return SourceLocation.parse(debugger, arg).then((loc) {
+      if (loc.valid) {
+        if (loc.function != null) {
+          debugger.console.printLine(
+              'Ignoring breakpoint at $loc: '
+              'Function entry breakpoints not yet implemented');
+          return null;
+        }
+        if (loc.col != null) {
+          // TODO(turnidge): Add tokenPos breakpoint support.
+          debugger.console.printLine(
+              'Ignoring column: '
+              'adding breakpoint at a specific column not yet implemented');
+        }
+        return debugger.isolate.addBreakpoint(loc.script, loc.line).then((result) {
+          if (result is DartError) {
+            debugger.console.printLine('Unable to set breakpoint at ${loc}');
+          } else {
+            // TODO(turnidge): Adding a duplicate breakpoint is
+            // currently ignored.  May want to change the protocol to
+            // inform us when this happens.
+
+            // The BreakpointResolved event prints resolved
+            // breakpoints already.  Just print the unresolved ones here.
+            ServiceMap bpt = result;
+            if (!bpt['resolved']) {
+              var script = bpt['location']['script'];
+              var bpId = bpt['breakpointNumber'];
+              var tokenPos = bpt['location']['tokenPos'];
+              return script.load().then((_) {
+                var line = script.tokenToLine(tokenPos);
+                var col = script.tokenToCol(tokenPos);
+                debugger.console.printLine(
+                    'Future breakpoint ${bpId} added at '
+                    '${script.name}:${line}:${col}');
+              });
+            }
+          }
+        });
+      } else {
+        debugger.console.printLine(loc.errorMessage);
+      }
+    });
+  }
+
+  Future<List<String>> complete(List<String> args) {
+    if (args.length != 1) {
+      return new Future.value([]);
+    }
+    // TODO - fix SourceLocation complete
+    return new Future.value(SourceLocation.complete(debugger, args[0]));
+  }
+}
+
+class ClearCommand extends DebuggerCommand {
+  ClearCommand(Debugger debugger) : super(debugger, 'clear', []);
+
+  Future run(List<String> args) {
+    if (args.length > 1) {
+      debugger.console.printLine('not implemented');
+      return new Future.value(null);
+    }
+    var arg = (args.length == 0 ? '' : args[0]);
+    return SourceLocation.parse(debugger, arg).then((loc) {
+      if (loc.valid) {
+        if (loc.function != null) {
+          debugger.console.printLine(
+              'Ignoring breakpoint at $loc: '
+              'Function entry breakpoints not yet implemented');
+          return null;
+        }
+        if (loc.col != null) {
+          // TODO(turnidge): Add tokenPos clear support.
+          debugger.console.printLine(
+              'Ignoring column: '
+              'clearing breakpoint at a specific column not yet implemented');
+        }
+
+        for (var bpt in debugger.isolate.breakpoints) {
+          var script = bpt['location']['script'];
+          if (script.id == loc.script.id) {
+            assert(script.loaded);
+            var line = script.tokenToLine(bpt['location']['tokenPos']);
+            if (line == loc.line) {
+              return debugger.isolate.removeBreakpoint(bpt).then((result) {
+                if (result is DartError) {
+                  debugger.console.printLine(
+                      'Unable to clear breakpoint at ${loc}: ${result.message}');
+                  return;
+                } else {
+                  // TODO(turnidge): Add a BreakpointRemoved event to
+                  // the service instead of printing here.
+                  var bpId = bpt['breakpointNumber'];
+                  debugger.console.printLine(
+                      'Breakpoint ${bpId} removed at ${loc}');
+                  return;
+                }
+              });
+            }
+          }
+        }
+        debugger.console.printLine('No breakpoint found at ${loc}');
+      } else {
+        debugger.console.printLine(loc.errorMessage);
+      }
+    });
+  }
+
+  Future<List<String>> complete(List<String> args) {
+    if (args.length != 1) {
+      return new Future.value([]);
+    }
+    return new Future.value(SourceLocation.complete(debugger, args[0]));
+  }
+}
+
 // TODO(turnidge): Add argument completion.
 class DeleteCommand extends DebuggerCommand {
   DeleteCommand(Debugger debugger) : super(debugger, 'delete', []);
 
   Future run(List<String> args) {
     if (args.length < 1) {
       debugger.console.printLine('delete expects one or more arguments');
       return new Future.value(null);
     }
     List toDelete = [];
@@ skipping 31 matching lines @@
     return debugger.isolate.reloadBreakpoints().then((_) {
       if (debugger.isolate.breakpoints.isEmpty) {
         debugger.console.printLine('No breakpoints');
       }
       for (var bpt in debugger.isolate.breakpoints) {
         var bpId = bpt['breakpointNumber'];
         var script = bpt['location']['script'];
         var tokenPos = bpt['location']['tokenPos'];
         var line = script.tokenToLine(tokenPos);
         var col = script.tokenToCol(tokenPos);
+        var extras = new StringBuffer();
+        if (!bpt['resolved']) {
+          extras.write(' unresolved');
+        }
+        if (!bpt['enabled']) {
+          extras.write(' disabled');
+        }
         debugger.console.printLine(
-            'Breakpoint ${bpId} at ${script.name}:${line}:${col}');
+            'Breakpoint ${bpId} at ${script.name}:${line}:${col}${extras}');
       }
     });
   }
 }
 
 class InfoIsolatesCommand extends DebuggerCommand {
   InfoIsolatesCommand(Debugger debugger) : super(debugger, 'isolates', []);
 
   Future run(List<String> args) {
     for (var isolate in debugger.isolate.vm.isolates) {
@@ skipping 35 matching lines @@
   RefreshCommand(Debugger debugger) : super(debugger, 'refresh', [
       new RefreshCoverageCommand(debugger),
   ]);
 
   Future run(List<String> args) {
     return debugger.refreshStack();
   }
 }
 
 // Tracks the state for an isolate debugging session.
-class Debugger {
+class ObservatoryDebugger extends Debugger {
   RootCommand cmd;
   DebuggerConsoleElement console;
   DebuggerStackElement stackElement;
   ServiceMap stack;
+  int currentFrame = 0;
 
-  Debugger() {
+  ObservatoryDebugger() {
     cmd = new RootCommand([
         new HelpCommand(this),
         new PauseCommand(this),
         new ContinueCommand(this),
         new NextCommand(this),
         new StepCommand(this),
         new FinishCommand(this),
+        new BreakCommand(this),
+        new ClearCommand(this),
         new DeleteCommand(this),
         new InfoCommand(this),
         new RefreshCommand(this),
     ]);
   }
 
   void set isolate(Isolate iso) {
     _isolate = iso;
     if (_isolate != null) {
       _isolate.reload().then((_) {
-        _isolate.vm.events.stream.listen(_onEvent);
-        _refreshStack(isolate.pauseEvent).then((_) {
-          reportStatus();
+        // TODO(turnidge): Currently the debugger relies on all libs
+        // being loaded.  Fix this.
+        var pending = [];
+        for (var lib in _isolate.libraries) {
+          if (!lib.loaded) {
+            pending.add(lib.load());
+          }
+        }
+        Future.wait(pending).then((_) {
+          _isolate.vm.events.stream.listen(_onEvent);
+          _refreshStack(isolate.pauseEvent).then((_) {
+            reportStatus();
+          });
         });
       });
     }
   }
   Isolate get isolate => _isolate;
   Isolate _isolate;
 
   void init() {
     console.newline();
     console.printBold("Type 'h' for help");
@@ skipping 19 matching lines @@
         stackElement.isSampled = true;
       }
     });
   }
 
   Future<ServiceMap> _refreshStack(ServiceEvent pauseEvent) {
     return isolate.getStack().then((result) {
       stack = result;
       // TODO(turnidge): Replace only the changed part of the stack to
       // reduce flicker.
-      // stackElement.stack = stack;
       stackElement.updateStack(stack, pauseEvent);
     });
   }
 
   void reportStatus() {
     if (_isolate.idle) {
       console.printLine('Isolate is idle');
     } else if (_isolate.running) {
       console.printLine("Isolate is running (type 'pause' to interrupt)");
     } else if (_isolate.pauseEvent != null) {
@@ skipping 46 matching lines @@
       case 'ExceptionThrown':
         _refreshStack(event).then((_) {
           _reportPause(event);
         });
         break;
 
       case 'IsolateResumed':
         console.printLine('Continuing...');
         break;
 
+      case 'BreakpointResolved':
+        var bpId = event.breakpoint['breakpointNumber'];
+        var script = event.breakpoint['location']['script'];
+        var tokenPos = event.breakpoint['location']['tokenPos'];
+        var line = script.tokenToLine(tokenPos);
+        var col = script.tokenToCol(tokenPos);
+        console.printLine(
+            'Breakpoint ${bpId} added at ${script.name}:${line}:${col}');
+        break;
+
       case '_Graph':
-      case 'BreakpointResolved':
       case 'IsolateCreated':
       case 'GC':
         // Ignore these events for now.
         break;
 
       default:
         console.printLine('Unrecognized event: $event');
         break;
     }
   }
 
-  String complete(String line) {
-    List<String> completions = cmd.completeCommand(line);
-    if (completions.length == 0) {
-      // No completions.  Leave the line alone.
-      return line;
-    } else if (completions.length == 1) {
-      // Unambiguous completion.
-      return completions[0];
-    } else {
-      // Ambigous completion.
-      completions = completions.map((s )=> s.trimRight()).toList();
-      completions.sort();
-      console.printBold(completions.toString());
+  static String _commonPrefix(String a, String b) {
+    int pos = 0;
+    while (pos < a.length && pos < b.length) {
+      if (a.codeUnitAt(pos) != b.codeUnitAt(pos)) {
+        break;
+      }
+      pos++;
+    }
+    return a.substring(0, pos);
+  }
 
-      // TODO(turnidge): Complete to common prefix of all completions.
-      return line;
+  static String _foldCompletions(List<String> values) {
+    if (values.length == 0) {
+      return '';
     }
+    var prefix = values[0];
+    for (int i = 1; i < values.length; i++) {
+      prefix = _commonPrefix(prefix, values[i]);
+    }
+    return prefix;
+  }
+
+  Future<String> complete(String line) {
+    return cmd.completeCommand(line).then((completions) {
+      if (completions.length == 0) {
+        // No completions.  Leave the line alone.
+        return line;
+      } else if (completions.length == 1) {
+        // Unambiguous completion.
+        return completions[0];
+      } else {
+        // Ambigous completion.
+        completions = completions.map((s )=> s.trimRight()).toList();
+        console.printBold(completions.toString());
+        return _foldCompletions(completions);
+      }
+    });
   }
 
   // TODO(turnidge): Implement real command line history.
   String lastCommand;
-  bool busy = false;
 
   Future run(String command) {
-    assert(!busy);
-    busy = true;
-    if (command == '') {
+    if (command == '' && lastCommand != null) {
       command = lastCommand;
     }
-    lastCommand = command;
     console.printBold('\$ $command');
     return cmd.runCommand(command).then((_) {
-      busy = false;
+      lastCommand = command;
     }).catchError((e) {
       console.printLine('ERROR $e');
     });
   }
 }
 
 @CustomTag('debugger-page')
 class DebuggerPageElement extends ObservatoryElement {
   @published Isolate isolate;
 
   isolateChanged(oldValue) {
     if (isolate != null) {
       debugger.isolate = isolate;
     }
   }
-  Debugger debugger = new Debugger();
+  ObservatoryDebugger debugger = new ObservatoryDebugger();
 
   DebuggerPageElement.created() : super.created();
 
   @override
   void attached() {
     super.attached();
 
     var navbarDiv = $['navbarDiv'];
     var stackDiv = $['stackDiv'];
     var splitterDiv = $['splitterDiv'];
@@ skipping 19 matching lines @@
     debugger.init();
   }
 
 }
 
 @CustomTag('debugger-stack')
 class DebuggerStackElement extends ObservatoryElement {
   @published Isolate isolate;
   @observable bool hasStack = false;
   @observable bool isSampled = false;
-  Debugger debugger = null;
+  ObservatoryDebugger debugger;
 
   _addFrame(List frameList, ObservableMap frameInfo, bool expand) {
     DebuggerFrameElement frameElement = new Element.tag('debugger-frame');
     frameElement.expand = expand;
     frameElement.frame = frameInfo;
 
     var li = new LIElement();
     li.classes.add('list-group-item');
     li.children.insert(0, frameElement);
 
@@ skipping 163 matching lines @@
     var br = new BRElement();
     $['consoleText'].children.add(br);
     br.scrollIntoView();
   }
 }
 
 @CustomTag('debugger-input')
 class DebuggerInputElement extends ObservatoryElement {
   @published Isolate isolate;
   @published String text = '';
-  @observable Debugger debugger;
+  @observable ObservatoryDebugger debugger;
+  @observable bool busy = false;
+
+  void _notBusy() {
+    busy = false;
+  }
 
   @override
   void ready() {
     super.ready();
     var textBox = $['textBox'];
     textBox.select();
     textBox.onKeyDown.listen((KeyboardEvent e) {
+        // TODO(turnidge): Ignore *all* key events while busy.
         switch (e.keyCode) {
           case KeyCode.TAB:
             e.preventDefault();
-            int cursorPos = textBox.selectionStart;
-            var completion = debugger.complete(text.substring(0, cursorPos));
-            text = completion + text.substring(cursorPos);
-            // TODO(turnidge): Move the cursor to the end of the
-            // completion, rather than the end of the string.
+            if (!busy) {
+              busy = true;
+              int cursorPos = textBox.selectionStart;
+              debugger.complete(text.substring(0, cursorPos)).then((completion) {
+                text = completion + text.substring(cursorPos);
+                // TODO(turnidge): Move the cursor to the end of the
+                // completion, rather than the end of the string.
+              }).whenComplete(_notBusy);
+            }
             break;
           case KeyCode.ENTER:
-            if (!debugger.busy) {
-              debugger.run(text);
+            if (!busy) {
+              busy = true;
+              var command = text;
               text = '';
+              debugger.run(command).whenComplete(_notBusy);
             }
             break;
         }
       });
   }
 
   DebuggerInputElement.created() : super.created();
 }