Improved profiler view and inclusive profile tree

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 1786 matching lines @@
 
   String toString() => 'Context($length)';
 }
 
 
 // TODO(koda): Sync this with VM.
 class FunctionKind {
   final String _strValue;
   FunctionKind._internal(this._strValue);
   toString() => _strValue;
-  bool isSynthetic() => [kCollected, kNative, kTag, kReused].contains(this);
-
+  bool isSynthetic() => [kCollected, kNative, kStub, kTag].contains(this);
+  bool isDart() => !isSynthetic();
+  bool isStub() => (this == kStub);
+  bool hasDartCode() => isDart() || isStub();
   static FunctionKind fromJSON(String value) {
     switch(value) {
       case 'kRegularFunction': return kRegularFunction;
       case 'kClosureFunction': return kClosureFunction;
       case 'kGetterFunction': return kGetterFunction;
       case 'kSetterFunction': return kSetterFunction;
       case 'kConstructor': return kConstructor;
       case 'kImplicitGetter': return kImplicitGetterFunction;
       case 'kImplicitSetter': return kImplicitSetterFunction;
+      case 'kImplicitStaticFinalGetter': return kImplicitStaticFinalGetter;
+      case 'kIrregexpFunction': return kIrregexpFunction;
       case 'kStaticInitializer': return kStaticInitializer;
       case 'kMethodExtractor': return kMethodExtractor;
       case 'kNoSuchMethodDispatcher': return kNoSuchMethodDispatcher;
       case 'kInvokeFieldDispatcher': return kInvokeFieldDispatcher;
       case 'Collected': return kCollected;
       case 'Native': return kNative;
+      case 'Stub': return kStub;
       case 'Tag': return kTag;
-      case 'Reused': return kReused;
     }
-    return kUNKNOWN;
+    print('did not understand $value');
+    throw new FallThroughError();
   }
 
   static FunctionKind kRegularFunction = new FunctionKind._internal('function');
   static FunctionKind kClosureFunction = new FunctionKind._internal('closure function');
   static FunctionKind kGetterFunction = new FunctionKind._internal('getter function');
   static FunctionKind kSetterFunction = new FunctionKind._internal('setter function');
   static FunctionKind kConstructor = new FunctionKind._internal('constructor');
   static FunctionKind kImplicitGetterFunction = new FunctionKind._internal('implicit getter function');
   static FunctionKind kImplicitSetterFunction = new FunctionKind._internal('implicit setter function');
+  static FunctionKind kImplicitStaticFinalGetter = new FunctionKind._internal('implicit static final getter');
+  static FunctionKind kIrregexpFunction = new FunctionKind._internal('ir regexp function');
   static FunctionKind kStaticInitializer = new FunctionKind._internal('static initializer');
   static FunctionKind kMethodExtractor = new FunctionKind._internal('method extractor');
   static FunctionKind kNoSuchMethodDispatcher = new FunctionKind._internal('noSuchMethod dispatcher');
   static FunctionKind kInvokeFieldDispatcher = new FunctionKind._internal('invoke field dispatcher');
   static FunctionKind kCollected = new FunctionKind._internal('Collected');
   static FunctionKind kNative = new FunctionKind._internal('Native');
   static FunctionKind kTag = new FunctionKind._internal('Tag');
-  static FunctionKind kReused = new FunctionKind._internal('Reused');
+  static FunctionKind kStub = new FunctionKind._internal('Stub');
   static FunctionKind kUNKNOWN = new FunctionKind._internal('UNKNOWN');
 }
 
 class ServiceFunction extends ServiceObject with Coverage {
   @observable Class owningClass;
   @observable Library owningLibrary;
   @observable bool isStatic;
   @observable bool isConst;
   @observable ServiceFunction parent;
   @observable Script script;
@@ skipping 482 matching lines @@
         return;
       }
     }
   }
 }
 
 class CodeKind {
   final _value;
   const CodeKind._internal(this._value);
   String toString() => '$_value';
-
+  bool isSynthetic() => [Collected, Native, Tag].contains(this);
+  bool isDart() => !isSynthetic();
   static CodeKind fromString(String s) {
     if (s == 'Native') {
       return Native;
     } else if (s == 'Dart') {
       return Dart;
     } else if (s == 'Collected') {
       return Collected;
-    } else if (s == 'Reused') {
-      return Reused;
     } else if (s == 'Tag') {
       return Tag;
+    } else if (s == 'Stub') {
+      return Stub;
     }
-    Logger.root.warning('Unknown code kind $s');
+    print('do not understand code kind $s');
     throw new FallThroughError();
   }
+  static const Collected = const CodeKind._internal('Collected');
+  static const Dart = const CodeKind._internal('Dart');
   static const Native = const CodeKind._internal('Native');
-  static const Dart = const CodeKind._internal('Dart');
-  static const Collected = const CodeKind._internal('Collected');
-  static const Reused = const CodeKind._internal('Reused');
+  static const Stub = const CodeKind._internal('Stub');
   static const Tag = const CodeKind._internal('Tag');
 }
 
 class CodeInlineInterval {
   final int start;
   final int end;
   final List<ServiceFunction> functions = new List<ServiceFunction>();
   bool contains(int pc) => (pc >= start) && (pc < end);
   CodeInlineInterval(this.start, this.end);
 }
@@ skipping 188 matching lines @@
     for (Map descriptor in descriptors) {
       _processDescriptor(descriptor);
     }
   }
 
   /// Returns true if [address] is contained inside [this].
   bool contains(int address) {
     return (address >= startAddress) && (address < endAddress);
   }
 
-  @reflectable bool get isDartCode => kind == CodeKind.Dart;
+  @reflectable bool get isDartCode => (kind == CodeKind.Dart) ||
+                                      (kind == CodeKind.Stub);
 }
 
 
 class SocketKind {
   final _value;
   const SocketKind._internal(this._value);
   String toString() => '$_value';
 
   static SocketKind fromString(String s) {
     if (s == 'Listening') {
@@ skipping 237 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);
     }
   }
 }