Show tooltip with local variable value in Observatory debugger

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;
 
 /// A [ServiceObject] represents a persistent object within the vm.
 abstract class ServiceObject extends Observable {
   static int LexicalSortName(ServiceObject o1, ServiceObject o2) {
     return o1.name.compareTo(o2.name);
@@ skipping 1812 matching lines @@
     typeClass = map['type_class'];
     userName = map['user_name'];
     referent = map['referent'];
     key = map['key'];
     value = map['value'];
 
     // We are fully loaded.
     _loaded = true;
   }
 
-  String get shortName => valueAsString != null ? valueAsString : 'a ${clazz.name}';
+  String get shortName {
+    if (isClosure) {
+      return closureFunc.qualifiedName;
+    }
+    if (valueAsString != null) {
+      return valueAsString;
+    }
+    return 'a ${clazz.name}';
+  }
 
   String toString() => 'Instance($shortName)';
 }
 
 
 class Context extends ServiceObject {
   @observable Class clazz;
   @observable int size;
 
   @observable var parentContext;
@@ skipping 217 matching lines @@
 
   bool get isBlank {
     // Compute isBlank on demand.
     if (_isBlank == null) {
       _isBlank = text.trim().isEmpty;
     }
     return _isBlank;
   }
   bool _isBlank;
 
+  bool get isTrivialLine => !possibleBpt;
+
   static bool _isTrivialToken(String token) {
     if (token == 'else') {
       return true;
     }
     for (var c in token.split('')) {
       switch (c) {
         case '{':
         case '}':
         case '(':
         case ')':
         case ';':
           break;
         default:
           return false;
       }
     }
     return true;
   }
 
   static bool _isTrivialLine(String text) {
+    if (text.trimLeft().startsWith('//')) {
+      return true;
+    }
     var wsTokens = text.split(new RegExp(r"(\s)+"));
     for (var wsToken in wsTokens) {
       var tokens = wsToken.split(new RegExp(r"(\b)"));
       for (var token in tokens) {
         if (!_isTrivialToken(token)) {
           return false;
         }
       }
     }
     return true;
@@ skipping 67 matching lines @@
 
   factory CallSiteEntry.fromMap(Map entryMap) {
     return new CallSiteEntry(entryMap['receiverContainer'],
                              entryMap['count'],
                              entryMap['target']);
   }
 
   String toString() => "CallSiteEntry(${receiverContainer.name}, $count)";
 }
 
+/// The location of a local variable reference in a script.
+class LocalVarLocation {
+  final int line;
+  final int column;
+  final int endColumn;
+  LocalVarLocation(this.line, this.column, this.endColumn);
+}
+
 class Script extends ServiceObject with Coverage {
   Set<CallSite> callSites = new Set<CallSite>();
   final lines = new ObservableList<ScriptLine>();
   final _hits = new Map<int, int>();
   @observable String kind;
   @observable int firstTokenPos;
   @observable int lastTokenPos;
   @observable int lineOffset;
   @observable int columnOffset;
   @observable Library library;
@@ skipping 136 matching lines @@
     var line = tokenToLine(bpt.tokenPos);
     getLine(line).addBreakpoint(bpt);
   }
 
   void _removeBreakpoint(Breakpoint bpt) {
     var line = tokenToLine(bpt.tokenPos);
     if (line != null) {
       getLine(line).removeBreakpoint(bpt);
     }
   }
+
+  List<LocalVarLocation> scanLineForLocalVariableLocations(Pattern pattern,
+                                                            String name,
+                                                            String lineContents,
+                                                            int lineNumber,
+                                                            int columnOffset) {
+    var r = <LocalVarLocation>[];
+
+    pattern.allMatches(lineContents).forEach((Match match) {
+      // We have a match but our regular expression may have matched extra
+      // characters on either side of the name. Tighten the location.
+      var nameStart = match.input.indexOf(name, match.start);
+      var column = nameStart + columnOffset;
+      var endColumn = column + name.length;
+      var localVarLocation = new LocalVarLocation(lineNumber,
+                                                  column,
+                                                  endColumn);
+      r.add(localVarLocation);
+    });
+
+    return r;
+  }
+
+  List<LocalVarLocation> scanForLocalVariableLocations(String name,
+                                                       int tokenPos,
+                                                       int endTokenPos) {
+    // A pattern that matches:
+    // start of line OR non-(alpha numeric OR period) character followed by
+    // name followed by
+    // a non-alpha numerc character.
+    //
+    // NOTE: This pattern can over match on both ends. This is corrected for
+    // [scanLineForLocalVariableLocationse].
+    var pattern = new RegExp("(^|[^A-Za-z0-9\.])$name[^A-Za-z0-9]");
+
+    // Result.
+    var r = <LocalVarLocation>[];
+
+    // Limits.
+    final lastLine = tokenToLine(endTokenPos);
+    if (lastLine == null) {
+      return r;
+    }
+    
+    final lastColumn = tokenToCol(endTokenPos);
+    if (lastColumn == null) {
+      return r;
+    }
+    // Current scan position.
+    var line = tokenToLine(tokenPos);
+    if (line == null) {
+      return r;
+    }
+    var column = tokenToCol(tokenPos);
+    if (column == null) {
+      return r;
+    }
+
+    // Move back by name length.
+    // TODO(johnmccutchan): Fix LocalVarDescriptor to set column before the
+    // identifier name.
+    column = math.max(0, column - name.length);
+
+    var lineContents;
+
+    if (line == lastLine) {
+      // Only one line.
+      if (!getLine(line).isTrivialLine) {
+        lineContents = getLine(line).text.substring(column, lastColumn - 1);
+        return scanLineForLocalVariableLocations(pattern,
+                                                  name,
+                                                  lineContents,
+                                                  line,
+                                                  column);
+      }
+    }
+
+    // Scan first line.
+    if (!getLine(line).isTrivialLine) {
+      lineContents = getLine(line).text.substring(column);
+      r.addAll(scanLineForLocalVariableLocations(pattern,
+                                                  name,
+                                                  lineContents,
+                                                  line++,
+                                                  column));
+    }
+
+    // Scan middle lines.
+    while (line < (lastLine - 1)) {
+      if (getLine(line).isTrivialLine) {
+        line++;
+        continue;
+      }
+      lineContents = getLine(line).text;
+      r.addAll(
+          scanLineForLocalVariableLocations(pattern,
+                                             name,
+                                             lineContents,
+                                             line++,
+                                             0));
+    }
+
+    // Scan last line.
+    if (!getLine(line).isTrivialLine) {
+      lineContents = getLine(line).text.substring(0, lastColumn - 1);
+      r.addAll(
+          scanLineForLocalVariableLocations(pattern,
+                                             name,
+                                             lineContents,
+                                             line,
+                                             0));
+    }
+    return r;
+  }
 }
 
 class PcDescriptor extends Observable {
   final int pcOffset;
   @reflectable final int deoptId;
   @reflectable final int tokenPos;
   @reflectable final int tryIndex;
   @reflectable final String kind;
   @observable Script script;
   @observable String formattedLine;
@@ skipping 657 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);
     }
   }
 }