anchor.diff:  /// Operations that only work if both arguments are integers.
   abstract class BinaryBitOperation implements BinaryOperation {
     const BinaryBitOperation();
  +
  +  @override
     ConstantValue fold(ConstantValue left, ConstantValue right) {
  -    if (left.isInt && right.isInt) {
  -      IntConstantValue leftInt = left;
  -      IntConstantValue rightInt = right;
  -      BigInt resultValue = foldInts(leftInt.intValue, rightInt.intValue);
  -      if (resultValue == null) return null;
  -      return createInt(resultValue);
  -    }
  -    return null;
  -  }
  -
  -  BigInt foldInts(BigInt left, BigInt right);
  -}
  -
  -/// In JavaScript we truncate the result to an unsigned 32 bit integer. Also, -0
  -/// is treated as if it was the integer 0.
  -class JavaScriptBinaryBitOperation implements BinaryOperation {
  -  final BinaryBitOperation dartBitOperation;
  -
  -  const JavaScriptBinaryBitOperation(this.dartBitOperation);
  -
  -  String get name => dartBitOperation.name;
  -
  -  ConstantValue fold(ConstantValue left, ConstantValue right) {
  +    ConstantValue _fold(ConstantValue left, ConstantValue right) {
  +      if (left.isInt && right.isInt) {
  +        IntConstantValue leftInt = left;
  +        IntConstantValue rightInt = right;
  +        BigInt resultValue = foldInts(leftInt.intValue, rightInt.intValue);
  +        if (resultValue == null) return null;
  +        return createInt(resultValue);
  +      }
  +      return null;
  +    }
  +
       // In JavaScript we don't check for -0 and treat it as if it was zero.
       if (left.isMinusZero) {
         left = createInt(BigInt.zero);
  
positive.code: 
  final _BITS32 = new BigInt.from(0xFFFFFFFF);
  
  const add = const JavaScriptAddOperation();
  const bitAnd = const JavaScriptBinaryBitOperation(const BitAndOperation());
  const bitNot = const BitNotOperation();
  const bitOr = const JavaScriptBinaryBitOperation(const BitOrOperation());
  const bitXor = const JavaScriptBinaryBitOperation(const BitXorOperation());
  const booleanAnd = const BooleanAndOperation();
  const booleanOr = const BooleanOrOperation();
  const divide =
      const JavaScriptBinaryArithmeticOperation(const DivideOperation());
  const equal = const EqualsOperation();
  const greaterEqual = const GreaterEqualOperation();
  const greater = const GreaterOperation();
  const identity = const JavaScriptIdentityOperation();
  const ifNull = const IfNullOperation();
  const lessEqual = const LessEqualOperation();
  const less = const LessOperation();
  const modulo =
      const JavaScriptBinaryArithmeticOperation(const ModuloOperation());
  const multiply =
      const JavaScriptBinaryArithmeticOperation(const MultiplyOperation());
  const negate = const JavaScriptNegateOperation();
  const not = const NotOperation();
  const remainder = const JavaScriptRemainderOperation();
  const shiftLeft =
      const JavaScriptBinaryBitOperation(const ShiftLeftOperation());
  const shiftRight = const JavaScriptShiftRightOperation();
  const subtract =
      const JavaScriptBinaryArithmeticOperation(const SubtractOperation());
  const truncatingDivide = const JavaScriptBinaryArithmeticOperation(
      const TruncatingDivideOperation());
  const codeUnitAt = const CodeUnitAtRuntimeOperation();
  const round = const JavaScriptRoundOperation();
  const abs = const UnfoldedUnaryOperation('abs');
  
  /// Returns true if [value] will turn into NaN or infinity
  
negative.code:     }
      return null;
    }
  
    @override
    apply(left, right) => left.codeUnitAt(right);
  }
  
  class RoundOperation implements UnaryOperation {
    @override
    final String name = 'round';
  
    const RoundOperation();
  
    @override
    ConstantValue fold(ConstantValue constant) {
      // Be careful to round() only values that do not throw on either the host or
      // target platform.
  