anchor.diff:          opname = "-";
         }
         UnaryOperator operator = UnaryOperator.parse(opname);
  -      result = lattice.unaryOp(operator, argument);
  +      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);
  -      result = lattice.binaryOp(operator, left, right);
  -    }
  -    finish(result);
  +      AbstractConstantValue result = lattice.binaryOp(operator, left, right);
  +      return finish(result, canReplace: !left.isNullable);
  +    }
  +    return finish(null);
     }
   
     void visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
  
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:     AbstractConstantValue receiver = getValue(node.receiver.definition);
      node.receiverIsNotNull = receiver.isDefinitelyNotNull;
      if (receiver.isNothing) {
        return setResult(node, lattice.nothing);
      }
  
      void finish(AbstractConstantValue result, {bool canReplace: false}) {
        if (result == null) {
          canReplace = false;
          result = lattice.getInvokeReturnType(node.selector, node.mask);
        }
        setResult(node, result, canReplace: canReplace);
      }
  
      if (node.selector.isGetter) {
  