Constant fold codeUnitAt via constant system

sdk/lib/_internal/compiler/implementation/constant_system_dart.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js;
 
 const DART_CONSTANT_SYSTEM = const DartConstantSystem();
 
 class BitNotOperation implements UnaryOperation {
   final String name = '~';
@@ skipping 300 matching lines @@
   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 DART_CONSTANT_SYSTEM.createBool(left == right);
   }
   apply(left, right) => identical(left, right);
 }
 
+abstract class CodeUnitAtOperation implements BinaryOperation {
+  final String name = 'charCodeAt';
+  const CodeUnitAtOperation();
+  apply(left, right) => left.codeUnitAt(right);
+}
+
+class CodeUnitAtConstantOperation extends CodeUnitAtOperation {
+  const CodeUnitAtConstantOperation();
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
+    // 'a'.codeUnitAt(0) is not a constant expression.
+    return null;
+  }
+}
+
+class CodeUnitAtRuntimeOperation extends CodeUnitAtOperation {
+  const CodeUnitAtRuntimeOperation();
+  IntConstantValue fold(ConstantValue left, ConstantValue right) {
+    if (left.isString && right.isInt) {
+      DartString dartString = left.primitiveValue;
+      int index = right.primitiveValue;
+      if (index < 0 || index >= dartString.length) return null;
+      String string = dartString.slowToString();
+      int value = string.codeUnitAt(index);
+      return DART_CONSTANT_SYSTEM.createInt(value);
+    }
+    return null;
+  }
+}
+
 /**
  * A constant system implementing the Dart semantics. This system relies on
  * the underlying runtime-system. That is, if dart2js is run in an environment
  * that doesn't correctly implement Dart's semantics this constant system will
  * not return the correct values.
  */
 class DartConstantSystem extends ConstantSystem {
   final add = const AddOperation();
   final bitAnd = const BitAndOperation();
   final bitNot = const BitNotOperation();
   final bitOr = const BitOrOperation();
   final bitXor = const BitXorOperation();
   final booleanAnd = const BooleanAndOperation();
   final booleanOr = const BooleanOrOperation();
   final divide = const DivideOperation();
   final equal = const EqualsOperation();
   final greaterEqual = const GreaterEqualOperation();
   final greater = const GreaterOperation();
   final identity = const IdentityOperation();
   final lessEqual = const LessEqualOperation();
   final less = const LessOperation();
   final modulo = const ModuloOperation();
   final multiply = const MultiplyOperation();
   final negate = const NegateOperation();
   final not = const NotOperation();
   final shiftLeft = const ShiftLeftOperation();
   final shiftRight = const ShiftRightOperation();
   final subtract = const SubtractOperation();
   final truncatingDivide = const TruncatingDivideOperation();
+  final codeUnitAt = const CodeUnitAtConstantOperation();
 
   const DartConstantSystem();
 
   IntConstantValue createInt(int i) => new IntConstantValue(i);
   DoubleConstantValue createDouble(double d) => new DoubleConstantValue(d);
   StringConstantValue createString(DartString string) {
     return new StringConstantValue(string);
   }
   BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
   NullConstantValue createNull() => new NullConstantValue();
   MapConstantValue createMap(Compiler compiler,
                              InterfaceType type,
                              List<ConstantValue> keys,
                              List<ConstantValue> values) {
     return new MapConstantValue(type, keys, values);
   }
 
   bool isInt(ConstantValue constant) => constant.isInt;
   bool isDouble(ConstantValue constant) => constant.isDouble;
   bool isString(ConstantValue constant) => constant.isString;
   bool isBool(ConstantValue constant) => constant.isBool;
   bool isNull(ConstantValue constant) => constant.isNull;
 
   bool isSubtype(Compiler compiler, DartType s, DartType t) {
     return compiler.types.isSubtype(s, t);
   }
 }