Switch to using SourceLocation universally in service protocol.

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 SourceLocation {
-  SourceLocation.file(this.script, this.line, this.col);
-  SourceLocation.func(this.function);
-  SourceLocation.error(this.errorMessage);
+class DebuggerLocation {
+  DebuggerLocation.file(this.script, this.line, this.col);
+  DebuggerLocation.func(this.function);
+  DebuggerLocation.error(this.errorMessage);
 
   static RegExp sourceLocMatcher = new RegExp(r'^([^\d:][^:]+:)?(\d+)(:\d+)?');
   static RegExp functionMatcher = new RegExp(r'^([^.]+)([.][^.]+)?');
 
   /// Parses a source location description.
   ///
   /// Formats:
   ///   ''                -  current position
   ///   13                -  line 13, current script
   ///   13:20             -  line 13, col 20, current script
   ///   script.dart:13    -  line 13, script.dart
   ///   script.dart:13:20 -  line 13, col 20, script.dart
   ///   main              -  function
   ///   FormatException   -  constructor
   ///   _SHA1._updateHash -  method
-  static Future<SourceLocation> parse(Debugger debugger, String locDesc) {
+  static Future<DebuggerLocation> parse(Debugger debugger, String locDesc) {
     if (locDesc == '') {
       // Special case: '' means return current location.
       return _currentLocation(debugger);
     }
 
     // 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 SourceLocation.error(
+    return new Future.value(new DebuggerLocation.error(
         "Invalid source location '${locDesc}'"));
   }
 
-  static Future<SourceLocation> _currentLocation(Debugger debugger) {
+  static Future<DebuggerLocation> _currentLocation(Debugger debugger) {
     ServiceMap stack = debugger.stack;
     if (stack == null || stack['frames'].length == 0) {
-      return new Future.value(new SourceLocation.error(
+      return new Future.value(new DebuggerLocation.error(
           'A script must be provided when the stack is empty'));
     }
     var frame = stack['frames'][debugger.currentFrame];
-    Script script = frame['script'];
+    Script script = frame.location.script;
     return script.load().then((_) {
-      var line = script.tokenToLine(frame['tokenPos']);
+      var line = script.tokenToLine(frame.location.tokenPos);
       // TODO(turnidge): Pass in the column here once the protocol supports it.
-      return new Future.value(new SourceLocation.file(script, line, null));
+      return new Future.value(new DebuggerLocation.file(script, line, null));
     });
   }
 
-  static Future<SourceLocation> _parseScriptLine(Debugger debugger,
-                                                 Match match) {
+  static Future<DebuggerLocation> _parseScriptLine(Debugger debugger,
+                                                   Match match) {
     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);
     if (line == -1) {
-      return new Future.value(new SourceLocation.error(
+      return new Future.value(new DebuggerLocation.error(
           "Line '${lineStr}' must be an integer"));
     }
     if (col == -1) {
-      return new Future.value(new SourceLocation.error(
+      return new Future.value(new DebuggerLocation.error(
           "Column '${colStr}' must be an integer"));
     }
 
     if (scriptName != null) {
       // Resolve the script.
       return _lookupScript(debugger.isolate, scriptName).then((scripts) {
         if (scripts.length == 0) {
-          return new SourceLocation.error("Script '${scriptName}' not found");
+          return new DebuggerLocation.error("Script '${scriptName}' not found");
         } else if (scripts.length == 1) {
-          return new SourceLocation.file(scripts[0], line, col);
+          return new DebuggerLocation.file(scripts[0], line, col);
         } else {
           // TODO(turnidge): Allow the user to disambiguate.
-          return new SourceLocation.error("Script '${scriptName}' is ambigous");
+          return new DebuggerLocation.error("Script '${scriptName}' is ambigous");
         }
       });
     } else {
       // No script provided.  Default to top of stack for now.
       ServiceMap stack = debugger.stack;
       if (stack == null || stack['frames'].length == 0) {
-        return new Future.value(new SourceLocation.error(
+        return new Future.value(new DebuggerLocation.error(
             'A script must be provided when the stack is empty'));
       }
-      Script script = stack['frames'][0]['script'];
-      return new Future.value(new SourceLocation.file(script, line, col));
+      Script script = stack['frames'][0].location.script;
+      return new Future.value(new DebuggerLocation.file(script, line, col));
     }
   }
 
   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());
@@ skipping 75 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<SourceLocation> _parseFunction(Debugger debugger,
+  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.
@@ skipping 19 matching lines @@
               }
             } else {
               if (functionName == function.name) {
                 functions.add(function);
               }
             }
           }
         }
       }
       if (functions.length == 0) {
-        return new SourceLocation.error(
+        return new DebuggerLocation.error(
             "Function '${match.group(0)}' not found");
       } else if (functions.length == 1) {
-        return new SourceLocation.func(functions[0]);
+        return new DebuggerLocation.func(functions[0]);
       } else {
         // TODO(turnidge): Allow the user to disambiguate.
-        return new SourceLocation.error(
+        return new DebuggerLocation.error(
             "Function '${match.group(0)}' is ambigous");
       }
-      return new SourceLocation.error('foo');
+      return new DebuggerLocation.error('foo');
     });
   }
 
   static RegExp partialSourceLocMatcher =
       new RegExp(r'^([^\d:]?[^:]+[:]?)?(\d+)?([:]\d+)?');
   static RegExp partialFunctionMatcher = new RegExp(r'^([^.]*)([.][^.]*)?');
 
   /// Completes a partial source location description.
   static Future<List<String>> complete(Debugger debugger, String locDesc) {
     List<Future<List<String>>> pending = [];
@@ skipping 96 matching lines @@
     return 'invalid source location (${errorMessage})';
   }
 
   Script script;
   int line;
   int col;
   ServiceFunction function;
   String errorMessage;
   bool get valid => (errorMessage == null);
 }