Use dartfmt on Observatory code

runtime/observatory/lib/src/debugger/debugger_location.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 debugger;
 
 class DebuggerLocation {
   DebuggerLocation.file(this.script, this.line, this.col);
   DebuggerLocation.func(this.function);
   DebuggerLocation.error(this.errorMessage);
@@ skipping 20 matching lines @@
 
     // Parse the location description.
     var match = sourceLocMatcher.firstMatch(locDesc);
     if (match != null) {
       return _parseScriptLine(debugger, match);
     }
     match = functionMatcher.firstMatch(locDesc);
     if (match != null) {
       return _parseFunction(debugger, match);
     }
-    return new Future.value(new DebuggerLocation.error(
-        "Invalid source location '${locDesc}'"));
+    return new Future.value(
+        new DebuggerLocation.error("Invalid source location '${locDesc}'"));
   }
 
   static Future<Frame> _currentFrame(Debugger debugger) async {
     ServiceMap stack = debugger.stack;
     if (stack == null || stack['frames'].length == 0) {
       return null;
     }
     return stack['frames'][debugger.currentFrame];
   }
 
   static Future<DebuggerLocation> _currentLocation(Debugger debugger) async {
     var frame = await _currentFrame(debugger);
     if (frame == null) {
       return new DebuggerLocation.error(
           'A script must be provided when the stack is empty');
     }
     Script script = frame.location.script;
     await script.load();
     var line = script.tokenToLine(frame.location.tokenPos);
     var col = script.tokenToCol(frame.location.tokenPos);
     return new DebuggerLocation.file(script, line, col);
   }
 
-  static Future<DebuggerLocation> _parseScriptLine(Debugger debugger,
-                                                   Match match) async {
+  static Future<DebuggerLocation> _parseScriptLine(
+      Debugger debugger, Match match) async {
     var scriptName = match.group(1);
     if (scriptName != null) {
       scriptName = scriptName.substring(0, scriptName.length - 1);
     }
     var lineStr = match.group(2);
     assert(lineStr != null);
     var colStr = match.group(3);
     if (colStr != null) {
       colStr = colStr.substring(1);
     }
-    var line = int.parse(lineStr, onError:(_) => -1);
-    var col = (colStr != null
-               ? int.parse(colStr, onError:(_) => -1)
-               : null);
+    var line = int.parse(lineStr, onError: (_) => -1);
+    var col = (colStr != null ? int.parse(colStr, onError: (_) => -1) : null);
     if (line == -1) {
-      return new Future.value(new DebuggerLocation.error(
-          "Line '${lineStr}' must be an integer"));
+      return new Future.value(
+          new DebuggerLocation.error("Line '${lineStr}' must be an integer"));
     }
     if (col == -1) {
-      return new Future.value(new DebuggerLocation.error(
-          "Column '${colStr}' must be an integer"));
+      return new Future.value(
+          new DebuggerLocation.error("Column '${colStr}' must be an integer"));
     }
 
     if (scriptName != null) {
       // Resolve the script.
       var scripts = await _lookupScript(debugger.isolate, scriptName);
       if (scripts.length == 0) {
         return new DebuggerLocation.error("Script '${scriptName}' not found");
       } else if (scripts.length == 1) {
         return new DebuggerLocation.file(scripts[0], line, col);
       } else {
         // TODO(turnidge): Allow the user to disambiguate.
-        return
-            new DebuggerLocation.error("Script '${scriptName}' is ambiguous");
+        return new DebuggerLocation.error(
+            "Script '${scriptName}' is ambiguous");
       }
     } else {
       // No script provided.  Default to top of stack for now.
       var frame = await _currentFrame(debugger);
       if (frame == null) {
         return new Future.value(new DebuggerLocation.error(
             'A script must be provided when the stack is empty'));
       }
       Script script = frame.location.script;
       await script.load();
       return new DebuggerLocation.file(script, line, col);
     }
   }
 
-  static Future<List<Script>> _lookupScript(Isolate isolate,
-                                            String name,
-                                            {bool allowPrefix: false}) {
+  static Future<List<Script>> _lookupScript(Isolate isolate, String name,
+      {bool allowPrefix: false}) {
     var pending = [];
     for (var lib in isolate.libraries) {
       if (!lib.loaded) {
         pending.add(lib.load());
       }
     }
     return Future.wait(pending).then((_) {
       List matches = [];
       for (var lib in isolate.libraries) {
         for (var script in lib.scripts) {
           if (allowPrefix) {
             if (script.name.startsWith(name)) {
               matches.add(script);
             }
           } else {
             if (name == script.name) {
               matches.add(script);
             }
           }
         }
       }
       return matches;
     });
   }
 
-  static List<ServiceFunction> _lookupFunction(Isolate isolate,
-                                               String name,
-                                               { bool allowPrefix: false }) {
+  static List<ServiceFunction> _lookupFunction(Isolate isolate, String name,
+      {bool allowPrefix: false}) {
     var matches = [];
     for (var lib in isolate.libraries) {
       assert(lib.loaded);
       for (var function in lib.functions) {
         if (allowPrefix) {
           if (function.name.startsWith(name)) {
             matches.add(function);
           }
         } else {
           if (name == function.name) {
             matches.add(function);
           }
         }
       }
     }
     return matches;
   }
 
-  static Future<List<Class>> _lookupClass(Isolate isolate,
-                                          String name,
-                                          { bool allowPrefix: false }) async {
+  static Future<List<Class>> _lookupClass(Isolate isolate, String name,
+      {bool allowPrefix: false}) async {
     if (isolate == null) {
       return [];
     }
     var pending = [];
     for (var lib in isolate.libraries) {
       assert(lib.loaded);
       for (var cls in lib.classes) {
         if (!cls.loaded) {
           pending.add(cls.load());
         }
@@ skipping 22 matching lines @@
       assert(cls.loaded);
       if (name == function.name) {
         return function;
       }
     }
     return null;
   }
 
   // TODO(turnidge): This does not handle named functions which are
   // inside of named functions, e.g. foo.bar.baz.
-  static Future<DebuggerLocation> _parseFunction(Debugger debugger,
-                                               Match match) {
+  static Future<DebuggerLocation> _parseFunction(
+      Debugger debugger, Match match) {
     Isolate isolate = debugger.isolate;
     var base = match.group(1);
     var qualifier = match.group(2);
     assert(base != null);
 
     return _lookupClass(isolate, base).then((classes) {
       var functions = [];
       if (qualifier == null) {
         // Unqualified name is either a function or a constructor.
         functions.addAll(_lookupFunction(isolate, base));
@@ skipping 56 matching lines @@
 
     return Future.wait(pending).then((List<List<String>> responses) {
       var completions = [];
       for (var response in responses) {
         completions.addAll(response);
       }
       return completions;
     });
   }
 
-  static Future<List<String>> _completeFunction(Debugger debugger,
-                                                Match match) {
+  static Future<List<String>> _completeFunction(
+      Debugger debugger, Match match) {
     Isolate isolate = debugger.isolate;
     var base = match.group(1);
     var qualifier = match.group(2);
     base = (base == null ? '' : base);
 
     if (qualifier == null) {
-      return _lookupClass(isolate, base, allowPrefix:true).then((classes) {
+      return _lookupClass(isolate, base, allowPrefix: true).then((classes) {
         var completions = [];
 
         // Complete top-level function names.
-        var functions = _lookupFunction(isolate, base, allowPrefix:true);
+        var functions = _lookupFunction(isolate, base, allowPrefix: true);
         var funcNames = functions.map((f) => f.name).toList();
         funcNames.sort();
         completions.addAll(funcNames);
 
         // Complete class names.
         var classNames = classes.map((f) => f.name).toList();
         classNames.sort();
         completions.addAll(classNames);
 
         return completions;
       });
     } else {
-      return _lookupClass(isolate, base, allowPrefix:false).then((classes) {
+      return _lookupClass(isolate, base, allowPrefix: false).then((classes) {
         var completions = [];
         for (var cls in classes) {
           for (var function in cls.functions) {
             if (function.kind == M.FunctionKind.constructor) {
               if (function.name.startsWith(match.group(0))) {
                 completions.add(function.name);
               }
             } else {
               if (function.qualifiedName.startsWith(match.group(0))) {
                 completions.add(function.qualifiedName);
@@ skipping 48 matching lines @@
       colStr = (colStr == null ? '' : colStr);
       if (colStr.startsWith(':')) {
         lineStrComplete = true;
         colStr = colStr.substring(1);
       }
     }
 
     if (!scriptNameComplete) {
       // The script name is incomplete.  Complete it.
       var scripts =
-          await _lookupScript(debugger.isolate, scriptName, allowPrefix:true);
+          await _lookupScript(debugger.isolate, scriptName, allowPrefix: true);
       List completions = [];
       for (var script in scripts) {
         completions.add(script.name + ':');
       }
       completions.sort();
       return completions;
-
     } else {
       // The script name is complete.  Look it up.
       var scripts =
-          await _lookupScript(debugger.isolate, scriptName, allowPrefix:false);
+          await _lookupScript(debugger.isolate, scriptName, allowPrefix: false);
       if (scripts.isEmpty) {
         return [];
       }
       var script = scripts[0];
       await script.load();
       if (!lineStrComplete) {
         // Complete the line.
         var sharedPrefix = '${script.name}:';
         List completions = [];
-        var report = await script.isolate.getSourceReport(
-            [Isolate.kPossibleBreakpointsReport], script);
+        var report = await script.isolate
+            .getSourceReport([Isolate.kPossibleBreakpointsReport], script);
         Set<int> possibleBpts = getPossibleBreakpointLines(report, script);
         for (var line in possibleBpts) {
           var currentLineStr = line.toString();
           if (currentLineStr.startsWith(lineStr)) {
             completions.add('${sharedPrefix}${currentLineStr} ');
             completions.add('${sharedPrefix}${currentLineStr}:');
           }
         }
         return completions;
-
       } else {
         // Complete the column.
         int lineNum = int.parse(lineStr);
         var scriptLine = script.getLine(lineNum);
         var sharedPrefix = '${script.name}:${lineStr}:';
         List completions = [];
         int maxCol = scriptLine.text.trimRight().runes.length;
         for (int i = 1; i <= maxCol; i++) {
           var currentColStr = i.toString();
           if (currentColStr.startsWith(colStr)) {
@@ skipping 18 matching lines @@
     return 'invalid source location (${errorMessage})';
   }
 
   Script script;
   int line;
   int col;
   ServiceFunction function;
   String errorMessage;
   bool get valid => (errorMessage == null);
 }