anchor.diff:  
     _newGetterFn(String name, bool useEval) {
       if (!useEval) return _newGetterNoEvalFn(name);
  -    // We give the getter function a name that associates it with the
  -    // class of the reflectee. This makes it easier to spot in profiles
  -    // and when debugging, but it also means that the underlying JavaScript
  -    // engine will only share the generated code for accessors on the
  +    // We use a comment that associates the generated function with the
  +    // class of the reflectee. This makes it more likely that the underlying
  +    // JavaScript engine will only share the generated code for accessors on the
       // same class (through caching of eval'ed code). This makes the
       // generated call to the getter - e.g. o.get$foo() - much more likely
       // to be monomorphic and inlineable.
       String className = JS('String', '#.constructor.name', reflectee);
  -    var body = "(function $className\$$name(o){return o.$name()})";
  -    return JS('', '(function(b){return eval(b)})(#)', body);
  +    String body = "/* $className */ return o.$name();";
  +    return JS('', 'new Function("o", #)', body);
     }
   
     _newGetterNoEvalFn(n) => JS('',
  
positive.code:     if (!useEval) return _newInterceptGetterNoEvalFn(name, interceptor);
      String className = JS('String', '#.constructor.name', interceptor);
      String functionName = '$className\$$name';
      var body =
          '(function(i) {'
          '  function $functionName(o){return i.$name(o)}'
          '  return $functionName;'
          '})';
      return JS('', '(function(b){return eval(b)})(#)(#)', body, interceptor);
    }
  
    _newInterceptGetterNoEvalFn(n, i) => JS('',
  
negative.code: 
    _newProbeFn(String id, bool useEval) {
      if (useEval) {
        String body = "return c.$id;";
        return JS('', 'new Function("c", #)', body);
      } else {
        return JS('', '(function(n){return(function(c){return c[n]})})(#)', id);
      }
  