anchor.diff:      return result;
     }
   
  -  @override
     apply(left, right) => identical(left, right);
   }
   
   class IfNullOperation implements BinaryOperation {
  -  @override
     final String name = '??';
  -
     const IfNullOperation();
  -
  -  @override
     ConstantValue fold(ConstantValue left, ConstantValue right) {
       if (left.isNull) return right;
       return left;
     }
   
  -  @override
     apply(left, right) => left ?? right;
   }
   
   class CodeUnitAtOperation implements BinaryOperation {
  -  @override
  -  final String name = 'charCodeAt';
  -
  +  String get name => 'charCodeAt';
     const CodeUnitAtOperation();
  -
  -  @override
  +  ConstantValue fold(ConstantValue left, ConstantValue right) => null;
  +  apply(left, right) => left.codeUnitAt(right);
  +}
  +
  +class CodeUnitAtRuntimeOperation extends CodeUnitAtOperation {
  +  const CodeUnitAtRuntimeOperation();
     IntConstantValue fold(ConstantValue left, ConstantValue right) {
       if (left.isString && right.isInt) {
         StringConstantValue stringConstant = left;
  
positive.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.
  
negative.code:     return createBool(left == right);
    }
  
    apply(left, right) => left == right;
  }
  
  class IdentityOperation implements BinaryOperation {
    final String name = '===';
    const IdentityOperation();
    BoolConstantValue fold(ConstantValue left, ConstantValue right) {
      // In order to preserve runtime semantics which says that NaN !== NaN don't
      // constant fold NaN === NaN. Otherwise the output depends on inlined
      // variables and other optimizations.
      if (left.isNaN && right.isNaN) return null;
      return createBool(left == right);
    }
  
    apply(left, right) => identical(left, right);
  }
  
  class JavaScriptIdentityOperation implements BinaryOperation {
    final IdentityOperation dartIdentityOperation = const IdentityOperation();
  
    const JavaScriptIdentityOperation();
  
    String get name => dartIdentityOperation.name;
  
    BoolConstantValue fold(ConstantValue left, ConstantValue right) {
      BoolConstantValue result = dartIdentityOperation.fold(left, right);
      if (result == null || result.boolValue) return result;
      // In JavaScript -0.0 === 0 and all doubles are equal to their integer
      // values. Furthermore NaN !== NaN.
  