anchor.diff:    foldNums(num left, num right);
   }
   
  -class JavaScriptBinaryArithmeticOperation implements BinaryOperation {
  -  final BinaryOperation dartArithmeticOperation;
  -
  -  const JavaScriptBinaryArithmeticOperation(this.dartArithmeticOperation);
  -
  -  String get name => dartArithmeticOperation.name;
  -
  -  ConstantValue fold(ConstantValue left, ConstantValue right) {
  -    ConstantValue result = dartArithmeticOperation.fold(left, right);
  -    if (result == null) return result;
  -    return _convertToJavaScriptConstant(result);
  -  }
  -
  -  apply(left, right) => dartArithmeticOperation.apply(left, right);
  -}
  -
   class SubtractOperation extends ArithmeticNumOperation {
  +  @override
     final String name = '-';
  +
     const SubtractOperation();
  +
  +  @override
     BigInt foldInts(BigInt left, BigInt right) => left - right;
  +
  +  @override
     num foldNums(num left, num right) => left - right;
  +
  +  @override
     apply(left, right) => left - right;
   }
   
   class MultiplyOperation extends ArithmeticNumOperation {
  +  @override
     final String name = '*';
  +
     const MultiplyOperation();
  +
  +  @override
     BigInt foldInts(BigInt left, BigInt right) => left * right;
  +
  +  @override
     num foldNums(num left, num right) => left * right;
  +
  +  @override
     apply(left, right) => left * right;
   }
   
   class ModuloOperation extends ArithmeticNumOperation {
  +  @override
     final String name = '%';
  +
     const ModuloOperation();
  +
  +  @override
     BigInt foldInts(BigInt left, BigInt right) {
       if (right == BigInt.zero) return null;
       return left % right;
     }
   
  +  @override
     num foldNums(num left, num right) => left % right;
  +
  +  @override
     apply(left, right) => left % right;
   }
   
  -class JavaScriptRemainderOperation extends ArithmeticNumOperation {
  -  String get name => 'remainder';
  -
  -  const JavaScriptRemainderOperation();
  -
  +class RemainderOperation extends ArithmeticNumOperation {
  +  @override
  +  final String name = 'remainder';
  +
  +  const RemainderOperation();
  +
  +  @override
     BigInt foldInts(BigInt left, BigInt right) {
       if (right == BigInt.zero) return null;
       return left.remainder(right);
     }
   
  +  @override
     num foldNums(num left, num right) => left.remainder(right);
  +
  +  @override
     apply(left, right) => left.remainder(right);
   }
   
   class TruncatingDivideOperation extends ArithmeticNumOperation {
  +  @override
     final String name = '~/';
  +
     const TruncatingDivideOperation();
  +
  +  @override
     BigInt foldInts(BigInt left, BigInt right) {
       if (right == BigInt.zero) return null;
       return left ~/ right;
     }
   
  +  @override
     BigInt foldNums(num left, num right) {
       num ratio = left / right;
       if (ratio.isNaN || ratio.isInfinite) return null;
       return new BigInt.from(ratio.truncate().toInt());
     }
   
  +  @override
     apply(left, right) => left ~/ right;
  +
  +  @override
     bool isTruncatingDivide() => true;
   }
   
   class DivideOperation extends ArithmeticNumOperation {
  +  @override
     final String name = '/';
  +
     const DivideOperation();
  +
  +  @override
     double foldInts(BigInt left, BigInt right) => left / right;
  +
  +  @override
     num foldNums(num left, num right) => left / right;
  +
  +  @override
     bool isDivide() => true;
  +
  +  @override
     apply(left, right) => left / right;
   }
   
   class AddOperation implements BinaryOperation {
  +  @override
     final String name = '+';
  +
     const AddOperation();
  +
  +  @override
     ConstantValue fold(ConstantValue left, ConstantValue right) {
  -    if (left.isInt && right.isInt) {
  -      IntConstantValue leftInt = left;
  -      IntConstantValue rightInt = right;
  -      BigInt result = leftInt.intValue + rightInt.intValue;
  -      return createInt(result);
  -    } else if (left.isNum && right.isNum) {
  -      NumConstantValue leftNum = left;
  -      NumConstantValue rightNum = right;
  -      double result = leftNum.doubleValue + rightNum.doubleValue;
  -      return createDouble(result);
  -    } else if (left.isString && right.isString) {
  -      StringConstantValue leftString = left;
  -      StringConstantValue rightString = right;
  -      String result = leftString.stringValue + rightString.stringValue;
  -      return createString(result);
  -    } else {
  -      return null;
  -    }
  -  }
  -
  -  apply(left, right) => left + right;
  -}
  -
  -class JavaScriptAddOperation implements BinaryOperation {
  -  final _addOperation = const AddOperation();
  -  String get name => _addOperation.name;
  -
  -  const JavaScriptAddOperation();
  -
  -  ConstantValue fold(ConstantValue left, ConstantValue right) {
  -    ConstantValue result = _addOperation.fold(left, right);
  +    ConstantValue _fold(ConstantValue left, ConstantValue right) {
  +      if (left.isInt && right.isInt) {
  +        IntConstantValue leftInt = left;
  +        IntConstantValue rightInt = right;
  +        BigInt result = leftInt.intValue + rightInt.intValue;
  +        return createInt(result);
  +      } else if (left.isNum && right.isNum) {
  +        NumConstantValue leftNum = left;
  +        NumConstantValue rightNum = right;
  +        double result = leftNum.doubleValue + rightNum.doubleValue;
  +        return createDouble(result);
  +      } else if (left.isString && right.isString) {
  +        StringConstantValue leftString = left;
  +        StringConstantValue rightString = right;
  +        String result = leftString.stringValue + rightString.stringValue;
  +        return createString(result);
  +      } else {
  +        return null;
  +      }
  +    }
  +
  +    ConstantValue result = _fold(left, right);
       if (result != null && result.isNum) {
         return _convertToJavaScriptConstant(result);
       }
       return result;
     }
   
  -  apply(left, right) => _addOperation.apply(left, right);
  +  @override
  +  apply(left, right) => left + right;
   }
   
   abstract class RelationalNumOperation implements BinaryOperation {
     const RelationalNumOperation();
  +
  +  @override
     ConstantValue fold(ConstantValue left, ConstantValue right) {
       if (!left.isNum || !right.isNum) return null;
       bool foldedValue;
  
positive.code: }
  
  class UnfoldedUnaryOperation implements UnaryOperation {
    final String name;
    const UnfoldedUnaryOperation(this.name);
    ConstantValue fold(ConstantValue constant) {
      return null;
    }
  
negative.code: 
  final _BITS32 = new BigInt.from(0xFFFFFFFF);
  
  const add = const AddOperation();
  const bitAnd = const BitAndOperation();
  const bitNot = const BitNotOperation();
  const bitOr = const BitOrOperation();
  const bitXor = const BitXorOperation();
  const booleanAnd = const BooleanAndOperation();
  const booleanOr = const BooleanOrOperation();
  const divide = const DivideOperation();
  const equal = const EqualsOperation();
  const greaterEqual = const GreaterEqualOperation();
  const greater = const GreaterOperation();
  const identity = const IdentityOperation();
  const ifNull = const IfNullOperation();
  const lessEqual = const LessEqualOperation();
  const less = const LessOperation();
  const modulo = const ModuloOperation();
  const multiply = const MultiplyOperation();
  const negate = const NegateOperation();
  const not = const NotOperation();
  const remainder = const RemainderOperation();
  const shiftLeft = const ShiftLeftOperation();
  const shiftRight = const ShiftRightOperation();
  const subtract = const SubtractOperation();
  const truncatingDivide = const TruncatingDivideOperation();
  const codeUnitAt = const CodeUnitAtOperation();
  const round = const RoundOperation();
  const abs = const UnfoldedUnaryOperation('abs');
  
  /// Returns true if [value] will turn into NaN or infinity
  