anchor.diff:  
     final Map<int, HInstruction> workmap = new Map<int, HInstruction>();
     final List<int> worklist = new List<int>();
  +  final Map<HInstruction, Function> pendingOptimizations =
  +      new Map<HInstruction, Function>();  
   
     final Compiler compiler;
     String get name => 'type propagator';
  
positive.code:   }
  
    void processWorklist() {
      while (!worklist.isEmpty) {
        int id = worklist.removeLast();
        HInstruction instruction = workmap[id];
        assert(instruction != null);
        workmap.remove(id);
        if (updateType(instruction)) {
          addDependentInstructionsToWorkList(instruction);
        }
      }
    }
  
    void addDependentInstructionsToWorkList(HInstruction instruction) {}
  
  
negative.code: 
    HType visitInvokeDynamic(HInvokeDynamic instruction) {
      if (instruction.isInterceptedCall) {
        // We cannot do the following optimization now, because we have
        // to wait for the type propagation to be stable. The receiver
        // of [instruction] might move from number to dynamic.
        pendingOptimizations.putIfAbsent(instruction, () => () {
          Selector selector = instruction.selector;
          if (selector.isOperator()
              && selector.name != const SourceString('==')) {
            if (checkReceiver(instruction)) {
              addAllUsersBut(instruction, instruction.inputs[1]);
            }
            if (!selector.isUnaryOperator() && checkArgument(instruction)) {
              addAllUsersBut(instruction, instruction.inputs[2]);
            }
          }
        });
      }
      return super.visitInvokeDynamic(instruction);
    }
  