anchor.diff:      if (node.selector.isGetter) {
         // Constant fold known length of containers.
         if (node.selector == Selectors.length) {
  -        AbstractConstantValue object = getValue(node.dartReceiver);
  -        if (typeSystem.isDefinitelyIndexable(object.type, allowNull: true)) {
  -          AbstractConstantValue length = lattice.lengthSpecial(object);
  -          return finish(length, canReplace: !object.isNullable);
  +        if (typeSystem.isDefinitelyIndexable(receiver.type, allowNull: true)) {
  +          AbstractConstantValue length = lattice.lengthSpecial(receiver);
  +          return finish(length, canReplace: !receiver.isNullable);
           }
         }
         return finish(null);
  
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:   }
  
    void visitInvokeMethod(InvokeMethod node) {
      AbstractConstantValue receiver = getValue(node.dartReceiver);
      node.receiverIsNotNull = receiver.isDefinitelyNotNull;
      if (receiver.isNothing) {
        return setResult(node, lattice.nothing);
  