anchor.diff:            }
           });
         }
  +
         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));
  +        if (info is StaticCallSiteTypeInformation &&
  +            info.selector != null &&
  +            info.selector.isCall) {
  +          // This is a constructor call to a class with a call method. So we
  +          // need to trace the call method here.
  +          assert(info.calledElement.isConstructor);
  +          ClassElement cls = info.calledElement.enclosingClass;
  +          FunctionElement callMethod =
  +              cls.lookupMember(Compiler.CALL_OPERATOR_NAME);
  +          assert(invariant(cls, callMethod != null));
  +          Iterable<FunctionElement> elements = [callMethod];
  +          trace(elements, new ClosureTracerVisitor(elements, info, this));
  +        } else {
  +          // 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 =
  +              new List<FunctionElement>.from(
  +                  info.callees.where((e) => e.isFunction));
  +          trace(elements, new ClosureTracerVisitor(elements, info, this));
  +        }
         } else {
           assert(info is ElementTypeInformation);
           trace([info.element],
  
positive.code:               print('${types.getInferredTypeOf(target).type} for ${target}');
              }
            }
          } else {
            print('${info.type} for some unknown kind of closure');
          }
  
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);
  