dart2js cps: Combine integer type check with bounds check.

pkg/compiler/lib/src/cps_ir/finalize.dart

 library dart2js.cps_ir.finalize;
 
 import 'cps_ir_nodes.dart';
 import 'cps_fragment.dart';
 import 'optimizers.dart' show Pass;
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../js_backend/backend_helpers.dart';
 import '../js/js.dart' as js;
 
 /// A transformation pass that must run immediately before the tree IR builder.
@@ skipping 24 matching lines @@
     return first.parent == second.parent.parent;
   }
 
   CpsFragment visitBoundsCheck(BoundsCheck node) {
     CpsFragment cps = new CpsFragment(node.sourceInformation);
     if (node.hasNoChecks) {
       node..replaceUsesWith(node.object.definition)..destroy();
       return cps;
     }
     Continuation fail = cps.letCont();
-    if (node.hasLowerBoundCheck) {
+    Primitive index = node.index.definition;
+    if (node.hasIntegerCheck) {
+      cps.ifTruthy(cps.applyBuiltin(BuiltinOperator.IsNotUnsigned32BitInteger,
+          [index, index]))
+          .invokeContinuation(fail);
+    } else if (node.hasLowerBoundCheck) {
       cps.ifTruthy(cps.applyBuiltin(BuiltinOperator.NumLt,
-          [node.index.definition, cps.makeZero()]))
+          [index, cps.makeZero()]))
           .invokeContinuation(fail);
     }
     if (node.hasUpperBoundCheck) {
       Primitive length = node.length.definition;
       if (length is GetLength &&
           length.hasExactlyOneUse &&
           areAdjacent(length, node)) {
         // Rebind the GetLength here, so it does not get stuck outside the
         // condition, blocked from propagating by the lower bounds check.
         LetPrim lengthBinding = length.parent;
         lengthBinding.remove();
         cps.letPrim(length);
       }
       cps.ifTruthy(cps.applyBuiltin(BuiltinOperator.NumGe,
-          [node.index.definition, length]))
+          [index, length]))
           .invokeContinuation(fail);
     }
     if (node.hasEmptinessCheck) {
       cps.ifTruthy(cps.applyBuiltin(BuiltinOperator.StrictEq,
           [node.length.definition, cps.makeZero()]))
           .invokeContinuation(fail);
     }
     cps.insideContinuation(fail).invokeStaticThrower(
           helpers.throwIndexOutOfRangeException,
-          [node.object.definition, node.index.definition]);
+          [node.object.definition, index]);
     node..replaceUsesWith(node.object.definition)..destroy();
     return cps;
   }
 
   void visitGetStatic(GetStatic node) {
     if (node.witness != null) {
       node..witness.unlink()..witness = null;
     }
   }
 
   void visitForeignCode(ForeignCode node) {
     if (js.isIdentityTemplate(node.codeTemplate)) {
       // The CPS builder replaces identity templates with refinements, except
       // when the refined type is an array type.  Some optimizations assume the
       // type of an object is immutable, but the type of an array can change
       // after allocation.  After the finalize pass, this assumption is no
       // longer needed, so we can replace the remaining idenitity templates.
       Refinement refinement = new Refinement(
           node.arguments.single.definition,
           node.type)..type = node.type;
       node.replaceWith(refinement);
     }
   }
 }