anchor.diff:                print('${types.getInferredTypeOf(target).type} for ${target}');
               }
             }
  +        } else if (info is StaticCallSiteTypeInformation) {
  +          ClassElement cls = info.calledElement.enclosingClass;
  +          FunctionElement callMethod =
  +              cls.lookupMember(Compiler.CALL_OPERATOR_NAME);
  +          print('${types.getInferredSignatureOf(callMethod)} for ${cls}');
           } else {
             print('${info.type} for some unknown kind of closure');
           }
  
positive.code:           }
          });
        }
        if (info is ClosureTypeInformation) {
          Iterable<FunctionElement> elements = [info.element];
          trace(elements, new ClosureTracerVisitor(elements, info, this));
        } else if (info is CallSiteTypeInformation) {
          // We only are interested in functions here, as other targets
          // of this closure call are not a root to trace but an intermediate
          // for some other function.
          Iterable<FunctionElement> elements = info.callees
              .where((e) => e.isFunction);
          trace(elements, new ClosureTracerVisitor(elements, info, this));
        } else {
          assert(info is ElementTypeInformation);
  
negative.code:     CallSiteTypeInformation info = new StaticCallSiteTypeInformation(
            types.currentMember, node, caller, callee, selector, mask, arguments,
            inLoop);
      // If this class has a 'call' method then we have essentially created a
      // closure here. Register it as such so that it is traced.
      if (selector != null && selector.isCall && callee.isConstructor) {
        ClassElement cls = callee.enclosingClass.declaration;
        if (cls.callType != null) {
          types.allocatedClosures.add(info);
        }
      }
      info.addToGraph(this);
      allocatedCalls.add(info);
      updateSideEffects(sideEffects, selector, callee);
  