anchor.diff:        this.calledElement,
         Selector selector,
         ArgumentsTypes arguments,
  -      TypeMask type) : super(call, enclosing, selector, arguments, type);
  +      bool inLoop,
  +      TypeMask type)
  +    : super(call, enclosing, selector, arguments, inLoop, type);
   
     void addToGraph(TypeGraphInferrerEngine inferrer) {
       ElementTypeInformation callee =
  
positive.code:                                          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,
          types.dynamicType.type);
      info.addToGraph(this);
      return info;
    }
  
  
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) {
  