anchor.diff:  }
   
   class LessOperation extends RelationalNumOperation {
  +  @override
     final String name = '<';
  +
     const LessOperation();
  +
  +  @override
     bool foldInts(BigInt left, BigInt right) => left < right;
  +
  +  @override
     bool foldNums(num left, num right) => left < right;
  +
  +  @override
     apply(left, right) => left < right;
   }
   
   class LessEqualOperation extends RelationalNumOperation {
  +  @override
     final String name = '<=';
  +
     const LessEqualOperation();
  +
  +  @override
     bool foldInts(BigInt left, BigInt right) => left <= right;
  +
  +  @override
     bool foldNums(num left, num right) => left <= right;
  +
  +  @override
     apply(left, right) => left <= right;
   }
   
   class GreaterOperation extends RelationalNumOperation {
  +  @override
     final String name = '>';
  +
     const GreaterOperation();
  +
  +  @override
     bool foldInts(BigInt left, BigInt right) => left > right;
  +
  +  @override
     bool foldNums(num left, num right) => left > right;
  +
  +  @override
     apply(left, right) => left > right;
   }
   
   class GreaterEqualOperation extends RelationalNumOperation {
  +  @override
     final String name = '>=';
  +
     const GreaterEqualOperation();
  +
  +  @override
     bool foldInts(BigInt left, BigInt right) => left >= right;
  +
  +  @override
     bool foldNums(num left, num right) => left >= right;
  +
  +  @override
     apply(left, right) => left >= right;
   }
   
   class EqualsOperation implements BinaryOperation {
  +  @override
     final String name = '==';
  +
     const EqualsOperation();
  +
  +  @override
     ConstantValue fold(ConstantValue left, ConstantValue right) {
       // Numbers need to be treated specially because: NaN != NaN, -0.0 == 0.0,
       // and 1 == 1.0.
  
positive.code: }
  
  class BooleanAndOperation extends BinaryBoolOperation {
    final String name = '&&';
    const BooleanAndOperation();
    bool foldBools(bool left, bool right) => left && right;
    apply(left, right) => left && right;
  }
  
  class BooleanOrOperation extends BinaryBoolOperation {
    final String name = '||';
    const BooleanOrOperation();
    bool foldBools(bool left, bool right) => left || right;
    apply(left, right) => left || right;
  }
  
  abstract class ArithmeticNumOperation implements BinaryOperation {
    const ArithmeticNumOperation();
    ConstantValue fold(ConstantValue left, ConstantValue right) {
      if (left.isNum && right.isNum) {
        NumConstantValue leftNum = left;
        NumConstantValue rightNum = right;
        var foldedValue;
        if (left.isInt && right.isInt) {
          IntConstantValue leftInt = leftNum;
          IntConstantValue rightInt = rightNum;
          foldedValue = foldInts(leftInt.intValue, rightInt.intValue);
        } else {
          foldedValue = foldNums(leftNum.doubleValue, rightNum.doubleValue);
        }
        // A division by 0 means that we might not have a folded value.
        if (foldedValue == null) return null;
        if (left.isInt && right.isInt && !isDivide() || isTruncatingDivide()) {
          assert(foldedValue is BigInt);
          return createInt(foldedValue);
        } else {
          return createDouble(foldedValue);
        }
      }
      return null;
    }
  
    bool isDivide() => false;
  
negative.code:     if (right.isMinusZero) {
        right = createInt(BigInt.zero);
      }
      IntConstantValue result = _fold(left, right);
      if (result != null) {
        // We convert the result of bit-operations to 32 bit unsigned integers.
        return _createInt32(result.intValue);
  