Switch to using SourceLocation universally in service protocol.

runtime/observatory/lib/src/service/object.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.
 
 part of service;
 
 /// An RpcException represents an exceptional event that happened
 /// while invoking an rpc.
 abstract class RpcException implements Exception {
   RpcException(this.message);
@@ skipping 157 matching lines @@
         break;
       case 'Counter':
         obj = new ServiceMetric._empty(owner);
         break;
       case 'Error':
         obj = new DartError._empty(owner);
         break;
       case 'Field':
         obj = new Field._empty(owner);
         break;
+      case 'Frame':
+        obj = new Frame._empty(owner);
+        break;
       case 'Function':
         obj = new ServiceFunction._empty(owner);
         break;
       case 'Gauge':
         obj = new ServiceMetric._empty(owner);
         break;
       case 'Isolate':
         obj = new Isolate._empty(owner.vm);
         break;
       case 'Library':
         obj = new Library._empty(owner);
         break;
+      case 'Message':
+        obj = new ServiceMessage._empty(owner);
+        break;
+      case 'SourceLocation':
+        obj = new SourceLocation._empty(owner);
+        break;
       case 'Object':
         switch (vmType) {
           case 'PcDescriptors':
             obj = new PcDescriptors._empty(owner);
             break;
           case 'LocalVarDescriptors':
             obj = new LocalVarDescriptors._empty(owner);
             break;
           case 'TokenStream':
             obj = new TokenStream._empty(owner);
@@ skipping 158 matching lines @@
 abstract class ServiceObjectOwner extends ServiceObject {
   /// Creates an empty [ServiceObjectOwner].
   ServiceObjectOwner._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   /// Builds a [ServiceObject] corresponding to the [id] from [map].
   /// The result may come from the cache.  The result will not necessarily
   /// be [loaded].
   ServiceObject getFromMap(ObservableMap map);
 }
 
+/// A [SourceLocation] represents a location or range in the source code.
+class SourceLocation extends ServiceObject {
+  Script script;
+  int tokenPos;
+  int endTokenPos;
+
+  SourceLocation._empty(ServiceObject owner) : super._empty(owner);
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    assert(!mapIsRef);
+    _upgradeCollection(map, owner);
+    script = map['script'];
+    tokenPos = map['tokenPos'];
+    assert(script != null && tokenPos != null);
+    endTokenPos = map['endTokenPos'];
+  }
+
+  String toString() {
+    if (endTokenPos == null) {
+      return '${script.name}:token(${tokenPos})';
+    } else {
+      return '${script.name}:tokens(${tokenPos}-${endTokenPos})';
+    }
+  }
+}
+
 /// State for a VM being inspected.
 abstract class VM extends ServiceObjectOwner {
   @reflectable VM get vm => this;
   @reflectable Isolate get isolate => null;
 
   // TODO(turnidge): The connection should not be stored in the VM object.
   bool get isDisconnected;
 
   // TODO(johnmccutchan): Ensure that isolates do not end up in _cache.
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
@@ skipping 545 matching lines @@
     return invokeRpcNoUpgrade('getIsolate', {});
   }
 
   @observable Class objectClass;
   @observable final rootClasses = new ObservableList<Class>();
   Map<int, Class> _classesByCid = new Map<int, Class>();
 
   @observable Library rootLibrary;
   @observable ObservableList<Library> libraries =
       new ObservableList<Library>();
-  @observable ObservableMap topFrame;
+  @observable Frame topFrame;
 
   @observable String name;
   @observable String vmName;
   @observable ServiceFunction entry;
 
   @observable final Map<String, double> timers =
       toObservable(new Map<String, double>());
 
   final HeapSpace newSpace = new HeapSpace();
   final HeapSpace oldSpace = new HeapSpace();
@@ skipping 206 matching lines @@
   Future<ServiceObject> addBreakpoint(Script script, int line) async {
     // TODO(turnidge): Pass line as an int instead of a string.
     try {
       Map params = {
         'scriptId': script.id,
         'line': '$line',
       };
       Breakpoint bpt = await invokeRpc('addBreakpoint', params);
       if (bpt.resolved &&
           script.loaded &&
-          script.tokenToLine(bpt.tokenPos) != line) {
+          script.tokenToLine(bpt.location.tokenPos) != line) {
         // TODO(turnidge): Can this still happen?
         script.getLine(line).possibleBpt = false;
       }
       return bpt;
     } on ServerRpcException catch(e) {
       if (e.code == ServerRpcException.kCannotAddBreakpoint) {
         // Unable to set a breakpoint at the desired line.
         script.getLine(line).possibleBpt = false;
       }
       rethrow;
@@ skipping 247 matching lines @@
   static const kConnectionClosed   = 'ConnectionClosed';
 
   ServiceEvent._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceEvent.connectionClosed(this.reason) : super._empty(null) {
     kind = kConnectionClosed;
   }
 
   @observable String kind;
   @observable Breakpoint breakpoint;
-  @observable ServiceMap topFrame;
+  @observable Frame topFrame;
   @observable ServiceMap exception;
   @observable ServiceObject inspectee;
   @observable ByteData data;
   @observable int count;
   @observable String reason;
   int chunkIndex, chunkCount, nodeCount;
 
   @observable bool get isPauseEvent {
     return (kind == kPauseStart ||
             kind == kPauseExit ||
             kind == kPauseBreakpoint ||
             kind == kPauseInterrupted ||
             kind == kPauseException);
   }
 
   void _update(ObservableMap map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
     assert(map['isolate'] == null || owner == map['isolate']);
     kind = map['kind'];
     notifyPropertyChange(#isPauseEvent, 0, 1);
     name = 'ServiceEvent $kind';
     vmName = name;
     if (map['breakpoint'] != null) {
       breakpoint = map['breakpoint'];
     }
-    if (map['topFrame'] != null) {
-      topFrame = map['topFrame'];
-    }
+    topFrame = map['topFrame'];
     if (map['exception'] != null) {
       exception = map['exception'];
     }
     if (map['inspectee'] != null) {
       inspectee = map['inspectee'];
     }
     if (map['_data'] != null) {
       data = map['_data'];
     }
     if (map['chunkIndex'] != null) {
@@ skipping 25 matching lines @@
 
   // TODO(turnidge): Add state to track if a breakpoint has been
   // removed from the program.  Remove from the cache when deleted.
   bool get canCache => true;
   bool get immutable => false;
 
   // A unique integer identifier for this breakpoint.
   @observable int number;
 
   // Source location information.
-  @observable Script script;
-  @observable int tokenPos;
+  @observable SourceLocation location;
 
   // The breakpoint has been assigned to a final source location.
   @observable bool resolved;
 
   void _update(ObservableMap map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
 
     var newNumber = map['breakpointNumber'];
-    var newScript = map['location']['script'];
-    var newTokenPos = map['location']['tokenPos'];
+    // number never changes.
+    assert((number == null) || (number == newNumber));
+    number = newNumber;
 
-    // number and script never change.
-    assert((number == null) || (number == newNumber));
-    assert((script == null) || (script == newScript));
+    resolved = map['resolved'];
 
-    number = map['breakpointNumber'];
-    script = map['location']['script'];
-    resolved = map['resolved'];
-    bool tokenPosChanged = tokenPos != newTokenPos;
-
-    if (script.loaded &&
-        (tokenPos != null) &&
+    var oldLocation = location;
+    var newLocation = map['location'];
+    var oldScript;
+    var newScript;
+    var oldTokenPos;
+    var newTokenPos;
+    if (oldLocation != null) {
+      oldScript = location.script;
+      oldTokenPos = location.tokenPos;
+    }
+    if (newLocation != null) {
+      newScript = newLocation.script;
+      newTokenPos = newLocation.tokenPos;
+    }
+    // script never changes
+    assert((oldScript == null) || (oldScript == newScript));
+    bool tokenPosChanged = oldTokenPos != newTokenPos;
+    if (newScript.loaded &&
+        (newTokenPos != null) &&
         tokenPosChanged) {
       // The breakpoint has moved.  Remove it and add it later.
-      script._removeBreakpoint(this);
+      if (oldScript != null) {
+        oldScript._removeBreakpoint(this);
+      }
     }
-
-    tokenPos = newTokenPos;
-    if (script.loaded && tokenPosChanged) {
-      script._addBreakpoint(this);
+    location = newLocation;
+    if (newScript.loaded && tokenPosChanged) {
+      newScript._addBreakpoint(this);
     }
   }
 
   void remove() {
     // Remove any references to this breakpoint.  It has been removed.
-    script._removeBreakpoint(this);
+    location.script._removeBreakpoint(this);
     if ((isolate.pauseEvent != null) &&
         (isolate.pauseEvent.breakpoint != null) &&
         (isolate.pauseEvent.breakpoint.id == id)) {
       isolate.pauseEvent.breakpoint = null;
     }
   }
 
   String toString() {
     if (number != null) {
-      return 'Breakpoint ${number} at ${script.name}(token:${tokenPos})';
+      return 'Breakpoint ${number} at ${location})';
     } else {
       return 'Uninitialized breakpoint';
     }
   }
 }
 
 
 class LibraryDependency {
   @reflectable final bool isImport;
   @reflectable final bool isDeferred;
@@ skipping 95 matching lines @@
     accumulated.bytes = stats[ACCUMULATED_SIZE];
     current.instances = stats[LIVE_AFTER_GC] + stats[ALLOCATED_SINCE_GC];
     current.bytes = stats[LIVE_AFTER_GC_SIZE] + stats[ALLOCATED_SINCE_GC_SIZE];
   }
 
   bool get empty => accumulated.empty && current.empty;
 }
 
 class Class extends ServiceObject with Coverage {
   @observable Library library;
-  @observable Script script;
 
   @observable bool isAbstract;
   @observable bool isConst;
   @observable bool isFinalized;
   @observable bool isPatch;
   @observable bool isImplemented;
 
-  @observable int tokenPos;
-  @observable int endTokenPos;
+  @observable SourceLocation location;
 
   @observable ServiceMap error;
   @observable int vmCid;
 
   final Allocations newSpace = new Allocations();
   final Allocations oldSpace = new Allocations();
   final AllocationCount promotedByLastNewGC = new AllocationCount();
 
   @observable bool get hasNoAllocations => newSpace.empty && oldSpace.empty;
 
@@ skipping 26 matching lines @@
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     // Some builtin classes aren't associated with a library.
     if (map['library'] is Library) {
       library = map['library'];
     } else {
       library = null;
     }
 
-    script = map['script'];
-
+    location = map['location'];
     isAbstract = map['abstract'];
     isConst = map['const'];
     isFinalized = map['_finalized'];
     isPatch = map['_patch'];
     isImplemented = map['_implemented'];
 
-    tokenPos = map['tokenPos'];
-    endTokenPos = map['endTokenPos'];
-
     subclasses.clear();
     subclasses.addAll(map['subclasses']);
     subclasses.sort(ServiceObject.LexicalSortName);
 
     interfaces.clear();
     interfaces.addAll(map['interfaces']);
     interfaces.sort(ServiceObject.LexicalSortName);
 
     fields.clear();
     fields.addAll(map['fields']);
@@ skipping 212 matching lines @@
   static FunctionKind kStub = new FunctionKind._internal('Stub');
   static FunctionKind kUNKNOWN = new FunctionKind._internal('UNKNOWN');
 }
 
 class ServiceFunction extends ServiceObject with Coverage {
   // owner is a Library, Class, or ServiceFunction.
   @observable ServiceObject dartOwner;
   @observable Library library;
   @observable bool isStatic;
   @observable bool isConst;
-  @observable Script script;
-  @observable int tokenPos;
-  @observable int endTokenPos;
+  @observable SourceLocation location;
   @observable Code code;
   @observable Code unoptimizedCode;
   @observable bool isOptimizable;
   @observable bool isInlinable;
   @observable FunctionKind kind;
   @observable int deoptimizations;
   @observable String qualifiedName;
   @observable int usageCounter;
   @observable bool isDart;
   @observable ProfileFunction profile;
@@ skipping 28 matching lines @@
       qualifiedName = name;
     }
 
     if (mapIsRef) {
       return;
     }
 
     _loaded = true;
     isStatic = map['static'];
     isConst = map['const'];
-    script = map['script'];
-    tokenPos = map['tokenPos'];
-    endTokenPos = map['endTokenPos'];
+    location = map['location'];
     code = map['code'];
     isOptimizable = map['_optimizable'];
     isInlinable = map['_inlinable'];
     unoptimizedCode = map['_unoptimizedCode'];
     deoptimizations = map['_deoptimizations'];
     usageCounter = map['_usageCounter'];
   }
 }
 
 
 class Field extends ServiceObject {
   // Library or Class.
   @observable ServiceObject dartOwner;
   @observable Library library;
   @observable Instance declaredType;
   @observable bool isStatic;
   @observable bool isFinal;
   @observable bool isConst;
   @observable Instance staticValue;
   @observable String name;
   @observable String vmName;
 
   @observable bool guardNullable;
   @observable String guardClass;
   @observable String guardLength;
-  @observable Script script;
-  @observable int tokenPos;
+  @observable SourceLocation location;
 
   Field._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(ObservableMap map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     name = map['name'];
     vmName = (map.containsKey('vmName') ? map['vmName'] : name);
     dartOwner = map['owner'];
@@ skipping 11 matching lines @@
       library = dartOwner;
     }
 
     if (mapIsRef) {
       return;
     }
 
     guardNullable = map['_guardNullable'];
     guardClass = map['_guardClass'];
     guardLength = map['_guardLength'];
-    script = map['script'];
-    tokenPos = map['tokenPos'];
-
+    location = map['location'];
     _loaded = true;
   }
 
   String toString() => 'Field(${dartOwner.name}.$name)';
 }
 
 
 class ScriptLine extends Observable {
   final Script script;
   final int line;
@@ skipping 66 matching lines @@
     breakpoints.remove(bpt);
     if (breakpoints.isEmpty) {
       breakpoints = null;
       breakpointResolved = false;
     }
   }
 }
 
 class CallSite {
   final String name;
+  // TODO(turnidge): Use SourceLocation here instead.
   final Script script;
   final int tokenPos;
   final List<CallSiteEntry> entries;
 
   CallSite(this.name, this.script, this.tokenPos, this.entries);
 
   int get line => script.tokenToLine(tokenPos);
   int get column => script.tokenToCol(tokenPos);
 
   int get aggregateCount {
@@ skipping 168 matching lines @@
     var sourceLines = source.split('\n');
     if (sourceLines.length == 0) {
       return;
     }
     lines.clear();
     Logger.root.info('Adding ${sourceLines.length} source lines for ${uri}');
     for (var i = 0; i < sourceLines.length; i++) {
       lines.add(new ScriptLine(this, i + lineOffset + 1, sourceLines[i]));
     }
     for (var bpt in isolate.breakpoints.values) {
-      if (bpt.script == this) {
+      if (bpt.location.script == this) {
         _addBreakpoint(bpt);
       }
     }
 
     _applyHitsToLines();
     // Notify any Observers that this Script's state has changed.
     notifyChange(null);
   }
 
   void _applyHitsToLines() {
     for (var line in lines) {
       var hits = _hits[line.line];
       line.hits = hits;
     }
   }
 
   void _addBreakpoint(Breakpoint bpt) {
-    var line = tokenToLine(bpt.tokenPos);
+    var line = tokenToLine(bpt.location.tokenPos);
     getLine(line).addBreakpoint(bpt);
   }
 
   void _removeBreakpoint(Breakpoint bpt) {
-    var line = tokenToLine(bpt.tokenPos);
+    var line = tokenToLine(bpt.location.tokenPos);
     if (line != null) {
       getLine(line).removeBreakpoint(bpt);
     }
   }
 
   List<LocalVarLocation> scanLineForLocalVariableLocations(Pattern pattern,
                                                             String name,
                                                             String lineContents,
                                                             int lineNumber,
                                                             int columnOffset) {
@@ skipping 364 matching lines @@
     if (script != null) {
       // Already done.
       return;
     }
     if (kind != CodeKind.Dart){
       return;
     }
     if (function == null) {
       return;
     }
-    if (function.script == null) {
+    if (function.location.script == null) {
       // Attempt to load the function.
       function.load().then((func) {
-        var script = function.script;
+        var script = function.location.script;
         if (script == null) {
           // Function doesn't have an associated script.
           return;
         }
         // Load the script and then update descriptors.
         script.load().then(_updateDescriptors);
       });
       return;
     }
     // Load the script and then update descriptors.
-    function.script.load().then(_updateDescriptors);
+    function.location.script.load().then(_updateDescriptors);
   }
 
   /// Reload [this]. Returns a future which completes to [this] or an
   /// exception.
   Future<ServiceObject> reload() {
     assert(kind != null);
     if (isDartCode) {
       // We only reload Dart code.
       return super.reload();
     }
@@ skipping 329 matching lines @@
   void _onPoll(_) {
     // Reload metrics and add a sample to each.
     for (var metric in metrics) {
       metric.reload().then((m) {
         m.addSample(new MetricSample(m.value));
       });
     }
   }
 }
 
+class Frame extends ServiceObject {
+  @observable int index;
+  @observable ServiceFunction function;
+  @observable SourceLocation location;
+  @observable Code code;
+  @observable List<ServiceMap> variables = new ObservableList<ServiceMap>();
+
+  Frame._empty(ServiceObject owner) : super._empty(owner);
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    assert(!mapIsRef);
+    _loaded = true;
+    _upgradeCollection(map, owner);
+    this.index = map['index'];
+    this.function = map['function'];
+    this.location = map['location'];
+    this.code = map['code'];
+    this.variables = map['vars'];
+  }
+}
+
+
+class ServiceMessage extends ServiceObject {
+  @observable int index;
+  @observable String messageObjectId;
+  @observable int size;
+  @observable ServiceFunction handler;
+  @observable SourceLocation location;
+
+  ServiceMessage._empty(ServiceObject owner) : super._empty(owner);
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    assert(!mapIsRef);
+    _loaded = true;
+    _upgradeCollection(map, owner);
+    this.messageObjectId = map['messageObjectId'];
+    this.index = map['index'];
+    this.size = map['size'];
+    this.handler = map['handler'];
+    this.location = map['location'];
+  }
+}
+
+
 // Returns true if [map] is a service map. i.e. it has the following keys:
 // 'id' and a 'type'.
 bool _isServiceMap(ObservableMap m) {
   return (m != null) && (m['type'] != null);
 }
 
 bool _hasRef(String type) => type.startsWith('@');
 String _stripRef(String type) => (_hasRef(type) ? type.substring(1) : type);
 
 /// Recursively upgrades all [ServiceObject]s inside [collection] which must
@@ skipping 27 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }