anchor.diff:      return left << right.toInt();
     }
   
  -  @override
     apply(left, right) => left << right;
   }
   
   class ShiftRightOperation extends BinaryBitOperation {
  -  @override
     final String name = '>>';
  -
     const ShiftRightOperation();
  -
  -  @override
  +  BigInt foldInts(BigInt left, BigInt right) {
  +    if (right < BigInt.zero) return null;
  +    return left >> right.toInt();
  +  }
  +
  +  apply(left, right) => left >> right;
  +}
  +
  +class JavaScriptShiftRightOperation extends JavaScriptBinaryBitOperation {
  +  const JavaScriptShiftRightOperation() : super(const ShiftRightOperation());
  +
     ConstantValue fold(ConstantValue left, ConstantValue right) {
       // Truncate the input value to 32 bits if necessary.
       if (left.isInt) {
  
positive.code: }
  
  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.
  
negative.code: }
  
  class NegateOperation implements UnaryOperation {
    final String name = 'negate';
    const NegateOperation();
    ConstantValue fold(ConstantValue constant) {
      if (constant.isInt) {
        IntConstantValue intConstant = constant;
        return createInt(-intConstant.intValue);
      }
      if (constant.isDouble) {
        DoubleConstantValue doubleConstant = constant;
        return createDouble(-doubleConstant.doubleValue);
      }
      return null;
    }
  }
  
  class JavaScriptNegateOperation implements UnaryOperation {
    final NegateOperation dartNegateOperation = const NegateOperation();
  
    const JavaScriptNegateOperation();
  
    String get name => dartNegateOperation.name;
  
    ConstantValue fold(ConstantValue constant) {
      if (constant.isInt) {
        IntConstantValue intConstant = constant;
        if (intConstant.intValue == BigInt.zero) {
          return createDouble(-0.0);
        }
      }
      return dartNegateOperation.fold(constant);
    }
  }
  
  class NotOperation implements UnaryOperation {
    final String name = '!';
    const NotOperation();
    ConstantValue fold(ConstantValue constant) {
      if (constant.isBool) {
        BoolConstantValue boolConstant = constant;
  