Add a value range analysis phase to remove bounds checks.

lib/compiler/implementation/js_backend/constant_system_javascript.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.
 
 const JAVA_SCRIPT_CONSTANT_SYSTEM = const JavaScriptConstantSystem();
 
 class JavaScriptBitNotOperation extends BitNotOperation {
   const JavaScriptBitNotOperation();
 
   Constant fold(Constant constant) {
@@ skipping 24 matching lines @@
     // In JavaScript we don't check for -0 and treat it as if it was zero.
     if (left.isMinusZero()) left = DART_CONSTANT_SYSTEM.createInt(0);
     if (right.isMinusZero()) right = DART_CONSTANT_SYSTEM.createInt(0);
     IntConstant result = dartBitOperation.fold(left, right);
     if (result != null) {
       // We convert the result of bit-operations to 32 bit unsigned integers.
       return JAVA_SCRIPT_CONSTANT_SYSTEM.createInt32(result.value);
     }
     return result;
   }
+
+  apply(left, right) => dartBitOperation.apply(left, right);
 }
 
 class JavaScriptShiftRightOperation extends JavaScriptBinaryBitOperation {
   const JavaScriptShiftRightOperation() : super(const ShiftRightOperation());
 
   Constant fold(Constant left, Constant right) {
     // Truncate the input value to 32 bits if necessary.
     if (left.isInt()) {
       IntConstant intConstant = left;
       int value = intConstant.value;
@@ skipping 25 matching lines @@
 
   Constant fold(Constant constant) {
     if (constant.isInt()) {
       IntConstant intConstant = constant;
       if (intConstant.value == 0) {
         return JAVA_SCRIPT_CONSTANT_SYSTEM.createDouble(-0.0);
       }
     }
     return dartNegateOperation.fold(constant);
   }
+  apply(value) => -value;
 }
 
 class JavaScriptBinaryArithmeticOperation implements BinaryOperation {
   final BinaryOperation dartArithmeticOperation;
 
   const JavaScriptBinaryArithmeticOperation(this.dartArithmeticOperation);
 
   bool isUserDefinable() => dartArithmeticOperation.isUserDefinable();
   SourceString get name => dartArithmeticOperation.name;
 
   Constant fold(Constant left, Constant right) {
     Constant result = dartArithmeticOperation.fold(left, right);
     if (result == null) return result;
     return JAVA_SCRIPT_CONSTANT_SYSTEM.convertToJavaScriptConstant(result);
   }
+
+  apply(left, right) => dartArithmeticOperation.apply(left, right);
 }
 
 class JavaScriptIdentityOperation implements BinaryOperation {
   final IdentityOperation dartIdentityOperation = const IdentityOperation();
 
   const JavaScriptIdentityOperation();
 
   bool isUserDefinable() => dartIdentityOperation.isUserDefinable();
   SourceString get name => dartIdentityOperation.name;
 
@@ skipping 107 matching lines @@
     // At runtime, an integer is both an integer and a double: the
     // integer type check is Math.floor, which will return true only
     // for real integers, and our double type check is 'typeof number'
     // which will return true for both integers and doubles.
     if (s.element == compiler.intClass && t.element == compiler.doubleClass) {
       return true;
     }
     return compiler.types.isSubtype(s, t);
   }
 }