Prevent unbounded growth of the getField/setField closure caches.

runtime/lib/mirrors_impl.dart

 // Copyright (c) 2012, 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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 import "dart:collection";
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new UnmodifiableMapView({});
@@ skipping 280 matching lines @@
     return other is _LocalInstanceMirror &&
            identical(_reflectee, other._reflectee);
   }
 
   int get hashCode {
     // Avoid hash collisions with the reflectee. This constant is in Smi range
     // and happens to be the inner padding from RFC 2104.
     return identityHashCode(_reflectee) ^ 0x36363636;
   }
 
-  // TODO(16539): Make these weak or soft.
+  // TODO(18445): Use an LRU cache.
   static var _getFieldClosures = new HashMap();
   static var _setFieldClosures = new HashMap();
   static var _getFieldCallCounts = new HashMap();
   static var _setFieldCallCounts = new HashMap();
   static const _closureThreshold = 20;
+  static const _cacheSizeLimit = 255;
 
   _getFieldSlow(unwrapped) {
     // Slow path factored out to give the fast path a better chance at being
     // inlined.
+    if (_getFieldCallCounts.length == 2 * _cacheSizeLimit) {
+      // Prevent unbounded cache growth.
+      _getFieldCallCounts = new HashMap();
+    }
     var callCount = _getFieldCallCounts[unwrapped];
     if (callCount == null) {
       callCount = 0;
     }
     if (callCount == _closureThreshold) {
-      // We've seen a success getter invocation a few times: time to invest in a
-      // closure.
+      // We've seen a successful setter invocation a few times: time to invest
+      // in a closure.
       var f;
       var atPosition = unwrapped.indexOf('@');
       if (atPosition == -1) {
         // Public symbol.
         f = _eval('(x) => x.$unwrapped', null);
       } else {
         // Private symbol.
         var withoutKey = unwrapped.substring(0, atPosition);
         var privateKey = unwrapped.substring(atPosition);
         f = _eval('(x) => x.$withoutKey', privateKey);
       }
+      if (_getFieldClosures.length == _cacheSizeLimit) {
+        // Prevent unbounded cache growth.
+        _getFieldClosures = new HashMap();
+      }
       _getFieldClosures[unwrapped] = f;
       _getFieldCallCounts.remove(unwrapped);  // We won't look for this again.
       return reflect(f(_reflectee));
     }
     var result = reflect(_invokeGetter(_reflectee, unwrapped));
     // Only update call count if we don't throw to avoid creating closures for
     // non-existent getters.
     _getFieldCallCounts[unwrapped] = callCount + 1;
     return result;
   }
 
   InstanceMirror getField(Symbol memberName) {
     var unwrapped = _n(memberName);
     var f = _getFieldClosures[unwrapped];
     return (f == null) ? _getFieldSlow(unwrapped) : reflect(f(_reflectee));
   }
 
   _setFieldSlow(unwrapped, arg) {
     // Slow path factored out to give the fast path a better chance at being
     // inlined.
+    if (_setFieldCallCounts.length == 2 * _cacheSizeLimit) {
+      _setFieldCallCounts = new HashMap();
+    }
     var callCount = _setFieldCallCounts[unwrapped];
     if (callCount == null) {
       callCount = 0;
     }
     if (callCount == _closureThreshold) {
-      // We've seen a success getter invocation a few times: time to invest in a
-      // closure.
+      // We've seen a successful getter invocation a few times: time to invest
+      // in a closure.
       var f;
       var atPosition = unwrapped.indexOf('@');
       if (atPosition == -1) {
         // Public symbol.
         f = _eval('(x, v) => x.$unwrapped = v', null);
       } else {
         // Private symbol.
         var withoutKey = unwrapped.substring(0, atPosition);
         var privateKey = unwrapped.substring(atPosition);
         f = _eval('(x, v) => x.$withoutKey = v', privateKey);
       }
+      if (_setFieldClosures.length == _cacheSizeLimit) {
+        // Prevent unbounded cache growth.
+        _setFieldClosures = new HashMap();
+      }
       _setFieldClosures[unwrapped] = f;
       _setFieldCallCounts.remove(unwrapped);
       return reflect(f(_reflectee, arg));
     }
     _invokeSetter(_reflectee, unwrapped, arg);
     var result = reflect(arg);
     // Only update call count if we don't throw to avoid creating closures for
     // non-existent setters.
     _setFieldCallCounts[unwrapped] = callCount + 1;
     return result;
@@ skipping 1215 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }