dart2js cps: Combine integer type check with bounds check.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 library dart2js.ir_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
 import 'cps_ir_nodes_sexpr.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
@@ skipping 763 matching lines @@
 
   Primitive get unrefined => value.definition.unrefined;
 
   void setParentPointers() {
     value.parent = this;
   }
 }
 
 /// Checks that [index] is a valid index on a given indexable [object].
 ///
-/// Compiles to the following, with a subset of the conditions in the `if`:
+/// In the simplest form, compiles to the following:
 ///
-///     if (index < 0 || index >= object.length || object.length === 0)
+///     if (index < 0 || index >= object.length)
 ///         ThrowIndexOutOfRangeException(object, index);
 ///
-/// [index] must be an integer, and [object] must refer to null or an indexable
-/// object, and [length] must be the length of [object] at the time of the
-/// check.
+/// In the general form, any of the following conditions can be checked:
+///
+///  Lower bound: `index >= 0`
+///  Upper bound: `index < object.length`
+///  Emptiness:   `object.length !== 0`
+///  Integerness: `index >>> 0 === index`
+///
+/// [index] must be an integer unless integerness is checked, and [object] must
+/// refer to null or an indexable object, and [length] must be the length of
+/// [object] at the time of the check.
 ///
 /// Returns [object] so the bounds check can be used to restrict code motion.
 /// It is possible to have a bounds check node that performs no checks but
 /// is retained to restrict code motion.
 ///
 /// The [index] reference may be null if there are no checks to perform,
 /// and the [length] reference may be null if there is no upper bound or
 /// emptiness check.
 ///
 /// If a separate code motion guard for the index is required, e.g. because it
@@ skipping 16 matching lines @@
   /// If true, check that `object.length !== 0`.
   ///
   /// Equivalent to a lower bound check with `object.length - 1` as the index,
   /// but this check is faster.
   ///
   /// Although [index] is not used in the condition, it is used to generate
   /// the thrown error.  Currently it is always `-1` for emptiness checks,
   /// because that corresponds to `object.length - 1` in the error case.
   bool get hasEmptinessCheck => checks & EMPTINESS != 0;
 
+  /// If true, check that `index` is an integer.
+  bool get hasIntegerCheck => checks & INTEGER != 0;
+
   /// True if the [length] is needed to perform the check.
   bool get lengthUsedInCheck => checks & (UPPER_BOUND | EMPTINESS) != 0;
 
   bool get hasNoChecks => checks == NONE;
 
   static const int UPPER_BOUND = 1 << 0;
   static const int LOWER_BOUND = 1 << 1;
   static const int EMPTINESS = 1 << 2; // See [hasEmptinessCheck].
+  static const int INTEGER = 1 << 3; // Check if index is an int.
   static const int BOTH_BOUNDS = UPPER_BOUND | LOWER_BOUND;
   static const int NONE = 0;
 
   BoundsCheck(Primitive object, Primitive index, Primitive length,
       [this.checks = BOTH_BOUNDS, this.sourceInformation])
       : this.object = new Reference<Primitive>(object),
         this.index = new Reference<Primitive>(index),
         this.length = length == null ? null : new Reference<Primitive>(length);
 
   BoundsCheck.noCheck(Primitive object, [this.sourceInformation])
       : this.object = new Reference<Primitive>(object),
         this.checks = NONE;
 
   accept(Visitor visitor) => visitor.visitBoundsCheck(this);
 
   void setParentPointers() {
     object.parent = this;
     if (index != null) {
       index.parent = this;
     }
     if (length != null) {
       length.parent = this;
     }
   }
 
   String get checkString {
-    if (hasUpperBoundCheck && hasLowerBoundCheck) {
-      return 'upper-lower-checks';
-    } else if (hasUpperBoundCheck) {
-      return 'upper-check';
-    } else if (hasLowerBoundCheck) {
-      return 'lower-check';
-    } else if (hasEmptinessCheck) {
-      return 'emptiness-check';
-    } else {
-      return 'no-check';
-    }
+    if (hasNoChecks) return 'no-check';
+    return [hasUpperBoundCheck ? 'upper' : null,
+        hasLowerBoundCheck ? 'lower' : null,
+        hasEmptinessCheck ? 'emptiness' : null,
+        hasIntegerCheck ? 'integer' : null,
+        'check']
+        .where((x) => x != null).join('-');
   }
 
   bool get isSafeForElimination => checks == NONE;
   bool get isSafeForReordering => false;
   bool get hasValue => true; // Can be referenced to restrict code motion.
 
   Primitive get effectiveDefinition => object.definition.effectiveDefinition;
 }
 
 /// Throw a [NoSuchMethodError] if [value] cannot respond to [selector].
@@ skipping 2090 matching lines @@
     plug(new Branch.loose(_definitions.getCopy(node.condition),
         _copies[node.trueContinuation.definition],
         _copies[node.falseContinuation.definition])
       ..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }