anchor.diff:      if (!useEval) return _newInterceptGetterNoEvalFn(name, interceptor);
       String className = JS('String', '#.constructor.name', interceptor);
       String functionName = '$className\$$name';
  -    var body =
  -        '(function(i) {'
  +    String body =
           '  function $functionName(o){return i.$name(o)}'
  -        '  return $functionName;'
  -        '})';
  -    return JS('', '(function(b){return eval(b)})(#)(#)', body, interceptor);
  +        '  return $functionName;';
  +    return JS('', '(new Function("i", #))(#)', body, interceptor);
     }
   
     _newInterceptGetterNoEvalFn(n, i) => JS('',
  
positive.code: 
    _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
      // 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);
    }
  
    _newGetterNoEvalFn(n) => 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);
      }
  