Add 'break' and 'clear' commands to Observatory debugger.

runtime/observatory/lib/src/cli/command.dart

 // Copyright (c) 2015, 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.
 
 part of cli;
 
 // Splits a line into a list of string args.
 List<String> _splitLine(String line) {
   var args = line.split(' ').where((arg) {
       return arg != ' ' && arg != '';
@@ skipping 22 matching lines @@
   // A command may optionally have sub-commands.
   List<Command> _children = [];
 
   _CommandBase _parent;
   int get _depth => (_parent == null ? 0 : _parent._depth + 1);
 
   // Override in subclasses to provide command-specific argument completion.
   //
   // Given a list of arguments to this command, provide a list of
   // possible completions for those arguments.
-  List<String> complete(List<String> args) => [];
+  Future<List<String>> complete(List<String> args) => new Future.value([]);
 
   // Override in subclasses to provide command-specific execution.
   Future run(List<String> args);
 
   // Returns a list of local subcommands which match the args.
   List<Command> _matchLocal(String arg, bool preferExact) {
     var matches = new List<Command>();
     for (var child in _children) {
       if (child.name.startsWith(arg)) {
         if (preferExact && child.name == arg) {
@@ skipping 21 matching lines @@
         return matches;
       } else {
         return childMatches;
       }
     } else {
       return matches;
     }
   }
 
   // Builds a list of completions for this command.
-  List<String> _buildCompletions(List<String> args,
-                                 bool addEmptyString) {
-    var completions = complete(args.sublist(_depth, args.length));
-    if (addEmptyString && completions.isEmpty && args[args.length - 1] == '') {
-      // Special case allowance for an empty particle at the end of
-      // the command.
-      completions = [''];
-    }
-    var prefix = _concatArgs(args, _depth);
-    return completions.map((str) => '${prefix}${str}').toList();
+  Future<List<String>> _buildCompletions(List<String> args,
+                                         bool addEmptyString) {
+    return complete(args.sublist(_depth, args.length))
+      .then((completions) {
+        if (addEmptyString && completions.isEmpty &&
+            args[args.length - 1] == '') {
+          // Special case allowance for an empty particle at the end of
+          // the command.
+          completions = [''];
+        }
+        var prefix = _concatArgs(args, _depth);
+        return completions.map((str) => '${prefix}${str}').toList();
+      });
   }
 
 }
 
 // The root of a tree of commands.
 class RootCommand extends _CommandBase {
   RootCommand(List<Command> children) : super(children);
 
   // Provides a list of possible completions for a line of text.
-  List<String> completeCommand(String line) {
+  Future<List<String>> completeCommand(String line) {
     var args = _splitLine(line);
     bool showAll = line.endsWith(' ') || args.isEmpty;
     if (showAll) {
       // Adding an empty string to the end causes us to match all
       // subcommands of the last command.
       args.add('');
     }
     var commands =  _match(args, false);
     if (commands.isEmpty) {
       // No matching commands.
-      return [];
+      return new Future.value([]);
     }
     int matchLen = commands[0]._depth;
     if (matchLen < args.length) {
       // We were able to find a command which matches a prefix of the
       // args, but not the full list.
       if (commands.length == 1) {
         // The matching command is unique.  Attempt to provide local
         // argument completion from the command.
         return commands[0]._buildCompletions(args, true);
       } else {
         // An ambiguous prefix match leaves us nowhere.  The user is
         // typing a bunch of stuff that we don't know how to complete.
-        return [];
+        return new Future.value([]);
       }
     }
 
     // We have found a set of commands which match all of the args.
     // Return the completions strings.
     var prefix = _concatArgs(args, args.length - 1);
     var completions =
         commands.map((command) => '${prefix}${command.name} ').toList();
     if (showAll && matchLen == args.length) {
       // If we are showing all possiblities, also include local
       // completions for the parent command.
-      completions.addAll(commands[0]._parent._buildCompletions(args, false));
+      return commands[0]._parent._buildCompletions(args, false)
+        .then((localCompletions) {
+          completions.addAll(localCompletions);
+          return completions;
+        });
     }
-    return completions;
+    return new Future.value(completions);
   }
 
   // Runs a command.
   Future runCommand(String line) {
     var args = _splitLine(line);
     var commands =  _match(args, true);
     if (commands.isEmpty) {
       // TODO(turnidge): Add a proper exception class for this.
       return new Future.error('notfound');
     } else if (commands.length == 1) {
@@ skipping 12 matching lines @@
 }
 
 // A node in the command tree.
 abstract class Command extends _CommandBase {
   Command(this.name, List<Command> children) : super(children);
 
   final name;
 
   toString() => 'Command(${name})';
 }