anchor.diff:    // JS helpers for getField optimizations.
     static bool isUndefined(x)
         => JS('bool', 'typeof # == "undefined"', x);
  +  static bool isMissingCache(x)
  +      => JS('bool', 'typeof # == "number"', x);
     static bool isMissingProbe(Symbol symbol)
         => JS('bool', 'typeof #.\$p == "undefined"', symbol);
  -  static bool isNewFunctionAllowed()
  +  static bool isEvalAllowed()
         => JS('bool', 'typeof dart_precompiled != "function"');
   
   
  -  /// The getter cache is specific to this [InstanceMirror]
  -  /// and maps reflective names to functions that will invoke
  -  /// the corresponding getter on the reflectee. The reflectee
  -  /// is passed to the function as the first argument to avoid
  -  /// the overhead of fetching it from this mirror repeatedly.
  +  /// The getter cache is lazily allocated after a couple
  +  /// of invocations of [InstanceMirror.getField]. The delay is
  +  /// used to avoid too aggressive caching and dynamic function
  +  /// generation for rarely used mirrors. The cache is specific to
  +  /// this [InstanceMirror] and maps reflective names to functions
  +  /// that will invoke the corresponding getter on the reflectee.
  +  /// The reflectee is passed to the function as the first argument
  +  /// to avoid the overhead of fetching it from this mirror repeatedly.
     /// The cache is lazily initialized to a JS object so we can
     /// benefit from "map transitions" in the underlying JavaScript
     /// engine to speed up cache probing.
  -  var _getterCache;
  +  var _getterCache = 4;
   
     InstanceMirror getField(Symbol fieldName) {
       // BUG(16400): This should be a labelled block, but that makes
  
positive.code:     // Return the result of the slow-path getter invocation.
      return result;
    }
  
    delegate(Invocation invocation) {
      return JSInvocationMirror.invokeFromMirror(invocation, reflectee);
  
negative.code:     String name = n(fieldName);
      var result = _invoke(fieldName, JSInvocationMirror.GETTER, name, const []);
      var cacheEntry = JsCache.fetch(_classInvocationCache, name);
      if (cacheEntry.isNoSuchMethod) {
        return result;
      }
  
      // Make sure we have a getter cache in this [InstanceMirror].
      var cache = _getterCache;
      if (isMissingCache(cache)) {
        if ((_getterCache = --cache) != 0) return result;
        cache = _getterCache = JS('=Object', '({})');
      }
  
      // Make sure that symbol [fieldName] has a cache probing function ($p).
      bool useEval = isEvalAllowed();
      if (isMissingProbe(fieldName)) {
        var probe = _newProbeFn(name, useEval);
        JS('void', '#.\$p = #', fieldName, probe);
      }
  
      // Create a new getter function and install it in the cache.
      var mangledName = cacheEntry.mangledName;
      var getter = (cacheEntry.isIntercepted)
          ? _newInterceptedGetterFn(mangledName, useEval)
          : _newGetterFn(mangledName, useEval);
      JS('void', '#[#] = #', cache, name, getter);
  
      // Initialize the last value (v) and last mirror (m) on the
  