Use the integer type to get rid of above 0 checks in bounds checks.

sdk/lib/_internal/compiler/implementation/ssa/value_range_analyzer.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 ssa;
 
 
 class ValueRangeInfo {
   final ConstantSystem constantSystem;
 
   IntValue intZero;
   IntValue intOne;
 
   ValueRangeInfo(this.constantSystem) {
     intZero = newIntValue(0);
     intOne = newIntValue(1);
   }
 
   Value newIntValue(int value) {
     return new IntValue(value, this);
   }
 
   Value newInstructionValue(HInstruction instruction) {
     return new InstructionValue(instruction, this);
   }
 
-  Value newLengthValue(HInstruction instruction) {
-    return new LengthValue(instruction, this);
+  Value newPositiveValue(HInstruction instruction) {
+    return new PositiveValue(instruction, this);
   }
 
   Value newAddValue(Value left, Value right) {
     return new AddValue(left, right, this);
   }
 
   Value newSubtractValue(Value left, Value right) {
     return new SubtractValue(left, right, this);
   }
 
@@ skipping 245 matching lines @@
     return info.newNegateValue(this);
   }
 
   bool get isNegative => false;
   bool get isPositive => false;
 
   String toString() => 'Instruction: $instruction';
 }
 
 /**
- * Special value for instructions that represent the length of an
- * array. The difference with an [InstructionValue] is that we know
- * the value is positive.
+ * Special value for instructions whose type is a positive integer.
  */
-class LengthValue extends InstructionValue {
-  LengthValue(HInstruction instruction, info) : super(instruction, info);
+class PositiveValue extends InstructionValue {

[sra1, 2013/11/27 20:29:36]

Zero is possible, but is not positive.
Perhaps leave it as "LengthValue", or rename to "Nonnegative" or some other
term.

+  PositiveValue(HInstruction instruction, info) : super(instruction, info);
   bool get isPositive => true;
-  String toString() => 'Length: $instruction';
 }
 
 /**
  * Represents a binary operation on two [Value], where the operation
  * did not yield a canonical value.
  */
 class BinaryOperationValue extends Value {
   final Value left;
   final Value right;
   BinaryOperationValue(this.left, this.right, info) : super(info);
@@ skipping 318 matching lines @@
         assert(range != null);
         ranges[instruction] = range;
       }
     }
 
     block.forEachPhi(visit);
     block.forEachInstruction(visit);
   }
 
   Range visitInstruction(HInstruction instruction) {
-    return info.newUnboundRange();
-  }
-
-  Range visitParameterValue(HParameterValue parameter) {
-    if (!parameter.isInteger(compiler)) return info.newUnboundRange();
-    Value value = info.newInstructionValue(parameter);
-    return info.newNormalizedRange(value, value);
+    if (instruction.isUInt32(compiler)) {
+      return info.newNormalizedRange(
+          info.intZero, info.newPositiveValue(instruction));
+    } else if (instruction.isInteger(compiler)) {
+      InstructionValue value = info.newInstructionValue(instruction);
+      return info.newNormalizedRange(value, value);
+    } else {
+      return info.newUnboundRange();
+    }
   }
 
   Range visitPhi(HPhi phi) {
     if (!phi.isInteger(compiler)) return info.newUnboundRange();
     // Some phases may replace instructions that change the inputs of
     // this phi. Only the [SsaTypesPropagation] phase will update the
     // phi type. Play it safe by assuming the [SsaTypesPropagation]
     // phase is not necessarily run before the [ValueRangeAnalyzer].
     if (phi.inputs.any((i) => !i.isInteger(compiler))) {
       return info.newUnboundRange();
@@ skipping 18 matching lines @@
     return info.newNormalizedRange(value, value);
   }
 
   Range visitFieldGet(HFieldGet fieldGet) {
     if (!fieldGet.isInteger(compiler)) return info.newUnboundRange();
     if (!fieldGet.receiver.isIndexablePrimitive(compiler)) {
       return visitInstruction(fieldGet);
     }
     JavaScriptBackend backend = compiler.backend;
     assert(fieldGet.element == backend.jsIndexableLength);
-    LengthValue value = info.newLengthValue(fieldGet);
+    PositiveValue value = info.newPositiveValue(fieldGet);
     // We know this range is above zero. To simplify the analysis, we
     // put the zero value as the lower bound of this range. This
     // allows to easily remove the second bound check in the following
     // expression: a[1] + a[0].
     return info.newNormalizedRange(info.intZero, value);
   }
 
   Range visitBoundsCheck(HBoundsCheck check) {
     // Save the next instruction, in case the check gets removed.
     HInstruction next = check.next;
@@ skipping 312 matching lines @@
   }
 
   Range handleBinaryOperation(HBinaryArithmetic instruction) {
     Range leftRange = visit(instruction.left);
     Range rightRange = visit(instruction.right);
     if (leftRange == null || rightRange == null) return null;
     BinaryOperation operation = instruction.operation(info.constantSystem);
     return operation.apply(leftRange, rightRange);
   }
 }