anchor.diff:    }
   
     /// 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));
  +  /// [selector] on [receiver].
  +  AbstractConstantValue getInvokeReturnType(
  +      Selector selector, AbstractConstantValue receiver) {
  +    return fromMask(typeSystem.getInvokeReturnType(selector, receiver.type));
     }
   
     AbstractConstantValue fromMask(TypeMask mask) {
  
positive.code:     // Calculate the resulting constant if possible.
      String opname = node.selector.name;
      if (node.arguments.length == 1) {
        AbstractConstantValue argument = getValue(node.dartReceiver);
        // Unary operator.
        if (opname == "unary-") {
          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);
    }
  
negative.code: 
      if (node.selector.isCall) {
        if (node.selector == Selectors.codeUnitAt) {
          AbstractConstantValue right = getValue(node.dartArgument(0));
          AbstractConstantValue result =
              lattice.codeUnitAtSpecial(receiver, right);
          return finish(result, canReplace: !receiver.isNullable);
        }
        return finish(null);
      }
  
      if (node.selector == Selectors.index) {
        AbstractConstantValue right = getValue(node.dartArgument(0));
        AbstractConstantValue result = lattice.indexSpecial(receiver, right);
        return finish(result, canReplace: !receiver.isNullable);
      }
  
      if (!node.selector.isOperator) {
  