anchor.diff:      if (right.isMinusZero) {
         right = createInt(BigInt.zero);
       }
  -    IntConstantValue result = dartBitOperation.fold(left, right);
  +    IntConstantValue result = _fold(left, right);
       if (result != null) {
         // We convert the result of bit-operations to 32 bit unsigned integers.
         return _createInt32(result.intValue);
  
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:     return left << right.toInt();
    }
  
    @override
    apply(left, right) => left << right;
  }
  
  class ShiftRightOperation extends BinaryBitOperation {
    @override
    final String name = '>>';
  
    const ShiftRightOperation();
  
    @override
    ConstantValue fold(ConstantValue left, ConstantValue right) {
      // Truncate the input value to 32 bits if necessary.
      if (left.isInt) {
  