anchor.diff:      AbstractConstantValue receiver = getValue(node.receiver.definition);
       node.receiverIsNotNull = receiver.isDefinitelyNotNull;
       if (receiver.isNothing) {
  -      setResult(node, lattice.nothing);
  -      return;  // And come back later.
  -    }
  -
  -    void finish(AbstractConstantValue result) {
  +      return setResult(node, lattice.nothing);
  +    }
  +
  +    void finish(AbstractConstantValue result, {bool canReplace: false}) {
         if (result == null) {
  -        setResult(node, lattice.getInvokeReturnType(node.selector, node.mask));
  -      } else {
  -        setResult(node, result, canReplace: true);
  -      }
  +        canReplace = false;
  +        result = lattice.getInvokeReturnType(node.selector, node.mask);
  +      }
  +      setResult(node, result, canReplace: canReplace);
       }
   
       if (node.selector.isGetter) {
  
positive.code:         AbstractConstantValue object = getValue(node.dartReceiver);
          if (typeSystem.isDefinitelyIndexable(object.type, allowNull: true)) {
            AbstractConstantValue length = lattice.lengthSpecial(object);
            if (length != null) {
              setResult(node, length, canReplace: !object.isNullable);
              return;
            }
          }
        }
        finish(null);
        return;
      }
  
      if (node.selector.isCall) {
        AbstractConstantValue result;
        if (node.selector == Selectors.codeUnitAt) {
          AbstractConstantValue object = getValue(node.dartReceiver);
          AbstractConstantValue right = getValue(node.dartArgument(0));
          result = lattice.codeUnitAtSpecial(object, right);
        }
        finish(result);
        return;
      }
  
      if (node.selector == Selectors.index) {
        AbstractConstantValue object = getValue(node.dartReceiver);
        AbstractConstantValue right = getValue(node.dartArgument(0));
        AbstractConstantValue result = lattice.indexSpecial(object, right);
        finish(result);
        return;
      }
  
      if (!node.selector.isOperator) {
        finish(null);
        return;
      }
  
      // Calculate the resulting constant if possible.
      AbstractConstantValue result;
      String opname = node.selector.name;
      if (node.arguments.length == 1) {
        AbstractConstantValue argument = getValue(node.dartReceiver);
  
negative.code:         opname = "-";
        }
        UnaryOperator operator = UnaryOperator.parse(opname);
        AbstractConstantValue result = lattice.unaryOp(operator, argument);
        return finish(result, canReplace: !argument.isNullable);
      } else if (node.arguments.length == 2) {
        // Binary operator.
        AbstractConstantValue left = getValue(node.dartReceiver);
        AbstractConstantValue right = getValue(node.dartArgument(0));
        BinaryOperator operator = BinaryOperator.parse(opname);
        AbstractConstantValue result = lattice.binaryOp(operator, left, right);
        return finish(result, canReplace: !left.isNullable);
      }
      return finish(null);
    }
  
    void visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
  