anchor.diff:    function setupStatic(name, holder, descriptor) {
       if (typeof descriptor == 'string') {
         holder[name] = function() {
  +        if (descriptor == null) {
  +          // Already compiled. This happens when we have calls to the static as
  +          // arguments to the static: `foo(foo(499))`;
  +          return holder[name].apply(this, arguments);
  +        }
           var method = compile(name, descriptor);
           holder[name] = method;
  +        descriptor = null;  // GC the descriptor.
           return method.apply(this, arguments);
         };
       } else {
  
positive.code: 
        function setupCompileAllAndDelegateStub(name) {
          holder[name] = function() {
            compileAllStubs();
            return holder[name].apply(this, arguments);
          };
        }
  
negative.code: 
    function setupClass(name, holder, descriptor) {
      var patch = function() {
        if (patch.ensureResolved == patch) {
          // We have not yet been compiled.
          var constructor = compileConstructor(name, descriptor);
          holder[name] = constructor;
          name = holder = descriptor = null;  // GC the captured arguments.
          // Make sure we can invoke 'ensureResolved' multiple times on the patch
          // function.
          patch.ensureResolved = function() { return constructor; };
          constructor.ensureResolved = function() { return this; };
        } else {
          // This can happen when arguments to the constructor are of the same
          // class, like in `new A(new A(null))`.
          constructor = patch.ensureResolved();
        }
        // If the patch has been called as "ensureResolved" return.
        if (this === patch) return constructor;
        var object = new constructor();
        constructor.apply(object, arguments);
        return object;
  