Add dead CodeRegionTable for tracking overwritten Dart code

runtime/bin/vmservice/client/lib/src/service/cache.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;
 
 /// Abstract [ServiceObjectCache].
 abstract class ServiceObjectCache<T extends ServiceObject> {
   final Isolate isolate;
   final _cache = new ObservableMap<String, T>();
@@ skipping 35 matching lines @@
     }
     return isolate.get(id).then(_addToCache);
   }
 
   /// If [obj] is cached, return the cached object. Otherwise, upgrades [obj]
   /// and adds the upgraded value to the cache.
   T putIfAbsent(ObservableMap obj) {
     assert(ServiceObject.isServiceMap(obj));
     String id = obj['id'];
     var type = obj['type'];
+    if (!cachesId(id)) {
+      Logger.root.warning('Cache does not cache this id: $id');
+    }
     assert(cachesId(id));
     if (contains(id)) {
       return this[id];
     }
     return _addToCache(_upgrade(obj));
   }
 
   T _addToCache(T so) {
     this[so.id] = so;
     return so;
@@ skipping 44 matching lines @@
     return codeList;
   }
 
   void _resetProfileData() {
     _cache.forEach((k, Code code) {
       code.resetProfileData();
     });
   }
 
   void _updateProfileData(ServiceMap profile, List<Code> codeTable) {
-    var codes = profile['codes'];
+    var codeRegions = profile['codes'];
     var sampleCount = profile['samples'];
-    for (var profileCode in codes) {
-      Code code = profileCode['code'];
-      code.updateProfileData(profileCode, codeTable, sampleCount);
+    for (var codeRegion in codeRegions) {
+      Code code = codeRegion['code'];
+      code.updateProfileData(codeRegion, codeTable, sampleCount);
     }
   }
 }
 
 class ClassCache extends ServiceObjectCache<ServiceMap> {
   ClassCache(Isolate isolate) : super(isolate);
 
   bool cachesId(String id) => _matcher.hasMatch(id);
   bool cachesType(String type) => ServiceObject.stripRef(type) == 'Class';
   ServiceMap _upgrade(ObservableMap obj) =>
       new ServiceMap.fromMap(isolate, obj);
 
   static final RegExp _matcher = new RegExp(r'classes/\d+$');
 }
+
+class FunctionCache extends ServiceObjectCache<ServiceMap> {
+  FunctionCache(Isolate isolate) : super(isolate);
+
+  bool cachesId(String id) => _native_matcher.hasMatch(id) ||
+                              _collected_matcher.hasMatch(id) ||
+                              _reused_matcher.hasMatch(id) ||
+                              _stub_matcher.hasMatch(id) ||
+                              _class_function_matcher.hasMatch(id) ||
+                              _class_closure_matcher.hasMatch(id) ||
+                              _class_implicit_closure_matcher.hasMatch(id) ||
+                              _class_dispatcher_matcher.hasMatch(id);

[turnidge, 2014/03/13 18:09:09]

Checking 8 regexps will be slower than checking 1 regexp that uses OR
internally.  What do you think of making a combined regexp?

[Cutch, 2014/03/13 20:52:26]

Done.

+
+  bool cachesType(String type) => ServiceObject.stripRef(type) == 'Function';
+  ServiceMap _upgrade(ObservableMap obj) =>
+      new ServiceMap.fromMap(isolate, obj);
+
+  static final RegExp _native_matcher = new RegExp(r'^functions/native-.+');
+  static final RegExp _collected_matcher =
+      new RegExp(r'^functions/collected-.+');
+  static final RegExp _reused_matcher =
+      new RegExp(r'^functions/reused-.+');
+  static final RegExp _stub_matcher =
+        new RegExp(r'^functions/stub-.+');
+  static final RegExp _class_function_matcher =
+      new RegExp(r'^classes/\d+/functions/.+');
+  static final RegExp _class_closure_matcher =
+        new RegExp(r'^classes/\d+/closures/.+');
+  static final RegExp _class_implicit_closure_matcher =
+          new RegExp(r'^classes/\d+/implicit_closures/.+');
+  static final RegExp _class_dispatcher_matcher =
+            new RegExp(r'^classes/\d+/dispatchers/.+');
+}