anchor.diff:  
       HInstruction receiver = node.receiver;
   
  -    // TODO(sra): We should consider each use individually and then all uses
  -    // together.  Each use might permit a different rewrite due to a refined
  -    // receiver type.  Self-interceptor rewrites are always beneficial since the
  -    // receiver is live at a invocation.  Constant-interceptor rewrites are only
  -    // guaranteed to be beneficial if they can eliminate the need for the
  -    // interceptor or reduce the uses to one that can be simplified with a
  -    // one-shot interceptor or optimized is-check.
  -
  -    if (canUseSelfForInterceptor(receiver, interceptedClasses)) {
  -      return rewriteToUseSelfAsInterceptor(node, receiver);
  -    }
  -
       // Try computing a constant interceptor.
       HInstruction constantInterceptor =
           tryComputeConstantInterceptor(receiver, interceptedClasses);
  
positive.code:     return false;
    }
  
    bool canUseSelfForInterceptor(
        HInstruction receiver, Set<ClassEntity> interceptedClasses) {
      if (receiver.canBePrimitive(_abstractValueDomain)) {
        // Primitives always need interceptors.
        return false;
      }
      if (receiver.canBeNull(_abstractValueDomain) &&
          interceptedClasses.contains(_commonElements.jsNullClass)) {
        // Need the JSNull interceptor.
        return false;
      }
  
      // All intercepted classes extend `Interceptor`, so if the receiver can't be
  
negative.code:     return result;
    }
  
    static int useCount(HInstruction user, HInstruction used) =>
        user.inputs.where((input) => input == used).length;
  
    bool visitInterceptor(HInterceptor node) {
      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).
  