anchor.diff:                                           bool inLoop) {
       if (selector.isClosureCall()) return types.dynamicType;
   
  -    if (inLoop && selector.mask != null) {
  -      // 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.
  -      // TODO(ngeoffray): We should move the filtering on the selector
  -      // in the backend. It is not the inferrer role to do this kind
  -      // of optimization.
  -      compiler.world.allFunctions.filter(selector).forEach((callee) {
  -        compiler.world.addFunctionCalledInLoop(callee);
  -      });
  -    }
       compiler.world.allFunctions.filter(selector).forEach((callee) {
         updateSideEffects(sideEffects, selector, callee);
       });
   
       DynamicCallSiteTypeInformation info = new DynamicCallSiteTypeInformation(
  -        node, caller, selector, receiverType, arguments,
  +        node, caller, selector, receiverType, arguments, inLoop,
           types.dynamicType.type);
       info.addToGraph(this);
  +    allocatedCalls.add(info);
       return info;
     }
   
  
positive.code:       this.calledElement,
        Selector selector,
        ArgumentsTypes arguments,
        TypeMask type) : super(call, enclosing, selector, arguments, type);
  
    void addToGraph(TypeGraphInferrerEngine inferrer) {
      ElementTypeInformation callee =
  
negative.code:         }
        });
      }
  
      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) {
  