anchor.diff:    }
   
     void visitInvokeMethod(InvokeMethod node) {
  -    AbstractConstantValue receiver = getValue(node.receiver.definition);
  +    AbstractConstantValue receiver = getValue(node.dartReceiver);
       node.receiverIsNotNull = receiver.isDefinitelyNotNull;
       if (receiver.isNothing) {
         return setResult(node, lattice.nothing);
  
positive.code:   }
  
    /// The possible return types of a method that may be targeted by
    /// [typedSelector]. If the given selector is not a [TypedSelector], any
    /// reachable method matching the selector may be targeted.
    AbstractConstantValue getInvokeReturnType(Selector selector, TypeMask mask) {
      return fromMask(typeSystem.getInvokeReturnType(selector, mask));
    }
  
    AbstractConstantValue fromMask(TypeMask mask) {
  
negative.code:     // Calculate the resulting constant if possible.
      String opname = node.selector.name;
      if (node.arguments.length == 1) {
        // Unary operator.
        if (opname == "unary-") {
          opname = "-";
        }
        UnaryOperator operator = UnaryOperator.parse(opname);
        AbstractConstantValue result = lattice.unaryOp(operator, receiver);
        return finish(result, canReplace: !receiver.isNullable);
      } else if (node.arguments.length == 2) {
        // Binary operator.
        AbstractConstantValue right = getValue(node.dartArgument(0));
        BinaryOperator operator = BinaryOperator.parse(opname);
        AbstractConstantValue result =
            lattice.binaryOp(operator, receiver, right);
        return finish(result, canReplace: !receiver.isNullable);
      }
      return finish(null);
    }
  