anchor.diff:        anything = new AbstractConstantValue.nonConstant(
             functionCompiler.typeSystem.dynamicType),
         nullValue = new AbstractConstantValue.constantValue(
  -          new NullConstantValue(), new TypeMask.empty());
  -
  -  final AbstractConstantValue nothing = new AbstractConstantValue.nothing();
  +          new NullConstantValue(), new TypeMask.empty()),
  +      trueValue = new AbstractConstantValue.constantValue(
  +          new TrueConstantValue(), functionCompiler.typeSystem.boolType),
  +      falseValue = new AbstractConstantValue.constantValue(
  +          new FalseConstantValue(), functionCompiler.typeSystem.boolType);
   
     AbstractConstantValue constant(ConstantValue value, [TypeMask type]) {
       if (type == null) type = typeSystem.getTypeOf(value);
  
positive.code: 
    AbstractConstantValue lessSpecial(AbstractConstantValue left,
                                      AbstractConstantValue right) {
      return foldBinary(constantSystem.less, left, right);
    }
  
    AbstractConstantValue lessEqualSpecial(AbstractConstantValue left,
                                           AbstractConstantValue right) {
      return foldBinary(constantSystem.lessEqual, left, right);
    }
  
    AbstractConstantValue greaterSpecial(AbstractConstantValue left,
                                         AbstractConstantValue right) {
      return foldBinary(constantSystem.greater, left, right);
    }
  
    AbstractConstantValue greaterEqualSpecial(AbstractConstantValue left,
                                              AbstractConstantValue right) {
      return foldBinary(constantSystem.greaterEqual, left, right);
    }
  
  
negative.code:   bool get isNullConstant => kind == CONSTANT && constant.isNull;
    bool get isTrueConstant => kind == CONSTANT && constant.isTrue;
    bool get isFalseConstant => kind == CONSTANT && constant.isFalse;
    bool get isZeroConstant => kind == CONSTANT && constant.isZero;
    bool get isZeroOrNegativeConstant {
      if (kind != CONSTANT || !constant.isNum) return false;
      PrimitiveConstantValue value = constant;
      return value.primitiveValue <= 0;
    }
    bool get isNegativeConstant {
      if (kind != CONSTANT || !constant.isNum) return false;
      PrimitiveConstantValue value = constant;
      return value.primitiveValue < 0;
    }
  
    bool get isNullable => kind != NOTHING && type.isNullable;
    bool get isDefinitelyNotNull => kind == NOTHING || !type.isNullable;
  