anchor.diff:          instruction.block.addBefore(instruction.next, converted);
           receiver.replaceAllUsersDominatedBy(converted.next, converted);
           addDependentInstructionsToWorkList(converted);
  -        _validTargetClasses[converted] = classes;
         }
       }
   
  
positive.code:     // Try to specialize the receiver after this call.
      if (receiver.dominatedUsers(instruction).length != 1
          && !selector.isClosureCall) {
        var targets = compiler.world.allFunctions.query(selector);
        _ClassSet classes = new _ClassSet.from(targets, classWorld,
            filter: _excludeNoSuchMethod);
        _ClassSet previousClasses = _validTargetClasses[receiver];
        TypeMask newType;
        // If we have previous knowledge, we use that to compute the typemask.
        // Otherwise, we have to use `targets` to also include the noSuchMethod
        // handlers, which are filtered out of `classes`.
        if (previousClasses != null) {
          classes = previousClasses.intersect(classes);
          newType = classes.computeMask();
        } else {
          newType = targets.computeMask(classWorld);
        }
        newType = newType.intersection(receiverType, classWorld);
        var next = instruction.next;
        if (next is HTypeKnown && next.checkedInput == receiver) {
  
negative.code:           next.knownType = next.instructionType = newType;
            addDependentInstructionsToWorkList(next);
          }
        } else if (newType != receiverType) {
          // Insert a refinement node after the call and update all
          // users dominated by the call to use that node instead of
          // [receiver].
  