anchor.diff:      // inferencing implementation.
       do {
         var cache = _getterCache;
  -      if (cache == null || isMissingProbe(fieldName)) break;
  +      if (isMissingCache(cache) || isMissingProbe(fieldName)) break;
         // If the [fieldName] has an associated probe function, we can use
         // it to read from the getter cache specific to this [InstanceMirror].
         var getter = JS('', '#.\$p(#)', fieldName, cache);
  
positive.code:     String name = n(fieldName);
      var result = _invoke(fieldName, JSInvocationMirror.GETTER, name, const []);
      var cacheEntry = JsCache.fetch(_classInvocationCache, name);
      if (cacheEntry.isNoSuchMethod || cacheEntry.isIntercepted) {
        return result;
      }
  
      // Make sure we have a getter cache in this [InstanceMirror].
      var cache = _getterCache;
      if (cache == null) {
        cache = _getterCache = JS('=Object', 'Object.create(null)');
      }
  
      // Make sure that symbol [fieldName] has a cache probing function ($p).
      if (isMissingProbe(fieldName)) {
        var probe = isNewFunctionAllowed()
            ? JS('', 'new Function("c", "return c." + # + ";")', name)
            : JS('', 'function (c) { return c[#]; }', name);
        JS('void', '#.\$p = #', fieldName, probe);
      }
  
      // Create a new getter function and install it in the cache.
      var mangledName = cacheEntry.mangledName;
      var getter = isNewFunctionAllowed()
            ? JS('', 'new Function("o", "return o." + # + "();")', mangledName)
            : JS('', 'function(o) { return o[#](); }', mangledName);
      JS('void', '#[#] = #', cache, name, getter);
  
      // Initialize the last value (v) and last mirror (m) on the
  
negative.code:   // 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 isEvalAllowed()
        => JS('bool', 'typeof dart_precompiled != "function"');
  
  
    /// 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 = 4;
  
    InstanceMirror getField(Symbol fieldName) {
      // BUG(16400): This should be a labelled block, but that makes
  