anchor.diff:      return result;
     }
   
  +  static int useCount(HInstruction user, HInstruction used) =>
  +      user.inputs.where((input) => input == used).length;
  +
     bool visitInterceptor(HInterceptor node) {
  -    if (node.isConstant()) return false;
  +    if (node.receiver.nonCheck() == _graph.explicitReceiverParameter) {
  +      // If `explicitReceiverParameter` is set it means the current method is an
  +      // interceptor method, and `this` is the interceptor.  The caller just did
  +      // `getInterceptor(foo).currentMethod(foo)` to enter the current method.
  +      node.block.rewrite(node, _graph.thisInstruction);
  +      return true;
  +    }
  +
  +    rewriteSelfInterceptorUses(node);
  +
  +    if (node.usedBy.isEmpty) return true;
   
       // Specialize the interceptor with set of classes it intercepts, considering
       // all uses.  (The specialized interceptor has a shorter dispatch chain).
  
positive.code:     return false;
    }
  
    bool rewriteToUseSelfAsInterceptor(HInterceptor node, HInstruction receiver) {
      for (HInstruction user in node.usedBy.toList()) {
        if (user is HIs) {
          user.changeUse(node, receiver);
        } else {
          // Use the potentially self-argument as new receiver. Note that the
          // self-argument could potentially have a tighter type than the
          // receiver which was the input to the interceptor.
          assert(user.inputs[0] == node);
          assert(receiver.nonCheck() == user.inputs[1].nonCheck());
          user.changeUse(node, user.inputs[1]);
        }
      }
      return false;
    }
  
    bool visitOneShotInterceptor(HOneShotInterceptor node) {
      HInstruction constant =
          tryComputeConstantInterceptor(node.inputs[1], node.interceptedClasses);
  
  
negative.code: 
      HInstruction receiver = node.receiver;
  
      // Try computing a constant interceptor.
      HInstruction constantInterceptor =
          tryComputeConstantInterceptor(receiver, interceptedClasses);
  