dart2js: replace calls to codeUnitAt when index has favourable type

pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart

 // Copyright (c) 2013, 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.
 
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart' show Name;
 import '../elements/entities.dart';
 import '../js_backend/js_backend.dart';
@@ skipping 23 matching lines @@
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
     return null;
   }
 
   void clearAllSideEffects(HInstruction instruction) {
     instruction.sideEffects.clearAllSideEffects();
     instruction.sideEffects.clearAllDependencies();
     instruction.setUseGvn();
   }
 
+  Selector renameToOptimizedSelector(
+      String name, Selector selector, Compiler compiler) {
+    if (selector.name == name) return selector;
+    JavaScriptBackend backend = compiler.backend;
+    return new Selector.call(
+        new Name(name, backend.helpers.interceptorsLibrary),
+        new CallStructure(selector.argumentCount));
+  }
+
   Operation operation(ConstantSystem constantSystem) => null;
 
   static InvokeDynamicSpecializer lookupSpecializer(Selector selector) {
     if (selector.isIndex) return const IndexSpecializer();
     if (selector.isIndexSet) return const IndexAssignSpecializer();
     String name = selector.name;
     if (selector.isOperator) {
       if (name == 'unary-') return const UnaryNegateSpecializer();
       if (name == '~') return const BitNotSpecializer();
       if (name == '+') return const AddSpecializer();
@@ skipping 180 matching lines @@
   }
 
   bool inputsAreUInt31(HInstruction instruction, ClosedWorld closedWorld) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     return left.isUInt31(closedWorld) && right.isUInt31(closedWorld);
   }
 
   HInstruction newBuiltinVariant(
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld);
-
-  Selector renameToOptimizedSelector(
-      String name, Selector selector, Compiler compiler) {
-    if (selector.name == name) return selector;
-    JavaScriptBackend backend = compiler.backend;
-    return new Selector.call(
-        new Name(name, backend.helpers.interceptorsLibrary),
-        new CallStructure(selector.argumentCount));
-  }
 }
 
 class AddSpecializer extends BinaryArithmeticSpecializer {
   const AddSpecializer();
 
   TypeMask computeTypeFromInputTypes(
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
     if (inputsAreUInt31(instruction, closedWorld)) {
       return closedWorld.commonMasks.uint32Type;
     }
@@ skipping 283 matching lines @@
     if (instruction.isConstantInteger()) {
       HConstant rightConstant = instruction;
       IntConstantValue intConstant = rightConstant.constant;
       int value = intConstant.primitiveValue;
       return value >= low && value <= high;
     }
     // TODO(sra): Integrate with the bit-width analysis in codegen.dart.
     if (instruction is HBitAnd) {
       return low == 0 &&
           (argumentInRange(instruction.inputs[0], low, high) ||
-           argumentInRange(instruction.inputs[1], low, high));
+              argumentInRange(instruction.inputs[1], low, high));
     }
     return false;
   }
 
   bool isPositive(HInstruction instruction, ClosedWorld closedWorld) {
     // TODO: We should use the value range analysis. Currently, ranges
     // are discarded just after the analysis.
     return instruction.isPositiveInteger(closedWorld);
   }
 }
@@ skipping 292 matching lines @@
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
     // TODO(sra): Implement a builtin HCodeUnitAt instruction and the same index
     // bounds checking optimizations as for HIndex.
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     if (receiver.isStringOrNull(closedWorld)) {
       // Even if there is no builtin equivalent instruction, we know
       // String.codeUnitAt does not have any side effect (other than throwing),
       // and that it can be GVN'ed.
       clearAllSideEffects(instruction);
+      if (instruction.inputs.last.isPositiveInteger(closedWorld)) {
+        instruction.selector = renameToOptimizedSelector(
+            '_codeUnitAt', instruction.selector, compiler);
+      }
     }
     return null;
   }
 }
 
 class IdempotentStringOperationSpecializer extends InvokeDynamicSpecializer {
   const IdempotentStringOperationSpecializer();
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
@@ skipping 43 matching lines @@
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     if (receiver.isNumberOrNull(closedWorld)) {
       // Even if there is no builtin equivalent instruction, we know the
       // instruction does not have any side effect, and that it can be GVN'ed.
       clearAllSideEffects(instruction);
     }
     return null;
   }
 }