anchor.diff:      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);
  
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: 
      // Trace closures to potentially infer argument types.
      types.allocatedClosures.forEach((info) {
  
        void trace(Iterable<FunctionElement> elements,
                   ClosureTracerVisitor tracer) {
          tracer.run();
  