anchor.diff:          }
         });
       }
  -  }
  -
  +
  +    processLoopInformation();
  +  }
  +
  +  void processLoopInformation() {
  +    allocatedCalls.forEach((info) {
  +      if (!info.inLoop) return;
  +      if (info is StaticCallSiteTypeInformation) {
  +        compiler.world.addFunctionCalledInLoop(info.calledElement);
  +      } else if (info.selector.mask != null
  +                 && !info.selector.mask.containsAll(compiler)) {
  +        // For instance methods, we only register a selector called in a
  +        // loop if it is a typed selector, to avoid marking too many
  +        // methods as being called from within a loop. This cuts down
  +        // on the code bloat.
  +        info.targets.forEach(compiler.world.addFunctionCalledInLoop);
  +      }
  +    });
  +  }
   
     void refineOptimistic() {
       while (!workQueue.isEmpty) {
  
positive.code:   final Element caller;
    final Selector selector;
    final ArgumentsTypes arguments;
  
    CallSiteTypeInformation(
        this.call,
        this.caller,
        this.selector,
        this.arguments,
        TypeMask type) : super(type, null, const <TypeInformation>[]);
  
    String toString() => 'Call site $call';
  
negative.code:       Selector selector,
        this.receiver,
        ArgumentsTypes arguments,
        bool inLoop,
        TypeMask type)
      : super(call, enclosing, selector, arguments, inLoop, type);
  
    void addToGraph(TypeGraphInferrerEngine inferrer) {
      assert(receiver != null);
  