Support column-based breakpoints in the VM and Observatory.

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 619 matching lines @@
       '        set <option>           # Get current value for option\n'
       '        set <option> <value>   # Set value for option';
 }
 
 class BreakCommand extends DebuggerCommand {
   BreakCommand(Debugger debugger) : super(debugger, 'break', []);
 
   Future run(List<String> args) async {
     if (args.length > 1) {
       debugger.console.print('not implemented');
-      return new Future.value(null);
+      return;
     }
     var arg = (args.length == 0 ? '' : args[0]);
     var loc = await DebuggerLocation.parse(debugger, arg);
     if (loc.valid) {
       if (loc.function != null) {
         try {
           await debugger.isolate.addBreakpointAtEntry(loc.function);
         } on ServerRpcException catch(e) {
           if (e.code == ServerRpcException.kCannotAddBreakpoint) {
             debugger.console.print('Unable to set breakpoint at ${loc}');
           } else {
             rethrow;
           }
         }
       } else {
         assert(loc.script != null);
-        if (loc.col != null) {
-          // TODO(turnidge): Add tokenPos breakpoint support.
+        var script = loc.script;
+        await script.load();
+        if (loc.line < 1 || loc.line > script.lines.length) {
           debugger.console.print(
-              'Ignoring column: '
-              'adding breakpoint at a specific column not yet implemented');
-          }
+              'line number must be in range [1,${script.lines.length}]');
+          return;
+        }
         try {
-          await debugger.isolate.addBreakpoint(loc.script, loc.line);
+          await debugger.isolate.addBreakpoint(script, loc.line, loc.col);
         } on ServerRpcException catch(e) {
           if (e.code == ServerRpcException.kCannotAddBreakpoint) {
             debugger.console.print('Unable to set breakpoint at ${loc}');
           } else {
             rethrow;
           }
         }
       }
     } else {
       debugger.console.print(loc.errorMessage);
@@ skipping 36 matching lines @@
       '  (e.g \'break test.dart:11:8\')\n'
       '        break <function>            '
       '# Break at the named function\n'
       '                                    '
       '  (e.g \'break main\' or \'break Class.someFunction\')\n';
 }
 
 class ClearCommand extends DebuggerCommand {
   ClearCommand(Debugger debugger) : super(debugger, 'clear', []);
 
-  Future run(List<String> args) {
+  Future run(List<String> args) async {
     if (args.length > 1) {
       debugger.console.print('not implemented');
-      return new Future.value(null);
+      return;
     }
     var arg = (args.length == 0 ? '' : args[0]);
-    return DebuggerLocation.parse(debugger, arg).then((loc) {
-      if (loc.valid) {
-        if (loc.function != null) {
-          debugger.console.print(
-              'Ignoring breakpoint at $loc: '
-              'Function entry breakpoints not yet implemented');
-          return null;
-        }
-        if (loc.col != null) {
-          // TODO(turnidge): Add tokenPos clear support.
-          debugger.console.print(
-              'Ignoring column: '
-              'clearing breakpoint at a specific column not yet implemented');
-        }
+    var loc = await DebuggerLocation.parse(debugger, arg);
+    if (!loc.valid) {
+      debugger.console.print(loc.errorMessage);
+      return;
+    }
+    if (loc.function != null) {
+      debugger.console.print(
+          'Ignoring breakpoint at $loc: '
+          'Clearing function breakpoints not yet implemented');
+      return;
+    }
 
-        for (var bpt in debugger.isolate.breakpoints.values) {
-          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.print(
-                      'Unable to clear breakpoint at ${loc}: ${result.message}');
-                  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}]');
+      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)) {
+          foundBreakpoint = true;
+          var result = await debugger.isolate.removeBreakpoint(bpt);
+          if (result is DartError) {
+            debugger.console.print(
+                'Error clearing breakpoint ${bpt.number}: ${result.message}');
           }
         }
-        debugger.console.print('No breakpoint found at ${loc}');
-      } else {
-        debugger.console.print(loc.errorMessage);
       }
-    });
+    }
+    if (!foundBreakpoint) {
+      debugger.console.print('No breakpoint found at ${loc}');
+    }
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
       return new Future.value([args.join('')]);
     }
     return new Future.value(DebuggerLocation.complete(debugger, args[0]));
   }
 
   String helpShort = 'Remove a breakpoint by source location or function name'
@@ skipping 66 matching lines @@
       'Remove a breakpoint by breakpoint id.\n'
       '\n'
       'Syntax: delete <bp-id>\n'
       '        delete <bp-id> <bp-id> ...\n';
 }
 
 class InfoBreakpointsCommand extends DebuggerCommand {
   InfoBreakpointsCommand(Debugger debugger)
       : super(debugger, 'breakpoints', []);
 
-  Future run(List<String> args) {
+  Future run(List<String> args) async {
     if (debugger.isolate.breakpoints.isEmpty) {
       debugger.console.print('No breakpoints');
     }
     List bpts = debugger.isolate.breakpoints.values.toList();
     bpts.sort((a, b) => a.number - b.number);
     for (var bpt in bpts) {
       var bpId = bpt.number;
-      var script = bpt.location.script;
-      var tokenPos = bpt.location.tokenPos;
-      var line = script.tokenToLine(tokenPos);
-      var col = script.tokenToCol(tokenPos);
+      var locString = await bpt.location.toUserString();
       if (!bpt.resolved) {
         debugger.console.print(
-            'Future breakpoint ${bpId} at ${script.name}:${line}:${col}');
+            'Future breakpoint ${bpId} at ${locString}');
       } else {
         debugger.console.print(
-            'Breakpoint ${bpId} at ${script.name}:${line}:${col}');
+            'Breakpoint ${bpId} at ${locString}');
       }
     }
-    return new Future.value(null);
   }
 
   String helpShort = 'List all breakpoints';
 
   String helpLong =
       'List all breakpoints.\n'
       '\n'
       'Syntax: info breakpoints\n';
 }
 
@@ skipping 501 matching lines @@
           // 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}');
         }
       });
     }
   }
 
-  Future _reportBreakpointEvent(ServiceEvent event) {
+  Future _reportBreakpointEvent(ServiceEvent event) async {
     var bpt = event.breakpoint;
     var verb = null;
     switch (event.kind) {
       case ServiceEvent.kBreakpointAdded:
         verb = 'added';
         break;
       case ServiceEvent.kBreakpointResolved:
         verb = 'resolved';
         break;
       case ServiceEvent.kBreakpointRemoved:
         verb = 'removed';
         break;
       default:
         break;
     }
     var script = bpt.location.script;
-    return script.load().then((_) {
-      var bpId = bpt.number;
-      var tokenPos = bpt.location.tokenPos;
-      var line = script.tokenToLine(tokenPos);
-      var col = script.tokenToCol(tokenPos);
-      if (bpt.resolved) {
-        console.print(
-            'Breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
-      } else {
-        console.print(
-            'Future breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
-      }
-    });
+    await script.load();
+
+    var bpId = bpt.number;
+    var locString = await bpt.location.toUserString();
+    if (bpt.resolved) {
+      console.print(
+          'Breakpoint ${bpId} ${verb} at ${locString}');
+    } else {
+      console.print(
+          'Future breakpoint ${bpId} ${verb} at ${locString}');
+    }
   }
 
   void onEvent(ServiceEvent event) {
     switch(event.kind) {
       case ServiceEvent.kIsolateStart:
         {
           var iso = event.owner;
           console.print(
               "Isolate ${iso.number} '${iso.name}' has been created");
         }
@@ skipping 928 matching lines @@
         }
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }