Add another type JSPositiveInt to show a range analysis in the inferrer would be very beneficial :-…

sdk/lib/_internal/compiler/implementation/ssa/optimize.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;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 196 matching lines @@
         StringConstant constant = constantInput.constant;
         return graph.addConstantInt(constant.length, compiler);
       } else if (actualReceiver.isConstantList()) {
         HConstant constantInput = actualReceiver;
         ListConstant constant = constantInput.constant;
         return graph.addConstantInt(constant.length, compiler);
       }
       Element element = backend.jsIndexableLength;
       bool isFixed = isFixedLength(actualReceiver.instructionType, compiler);
       HFieldGet result = new HFieldGet(
-          element, actualReceiver, backend.intType,
+          element, actualReceiver, backend.positiveIntType,
           isAssignable: !isFixed);
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
       MapConstant constant = constantInput.constant;
       return graph.addConstantInt(constant.length, compiler);
     }
     return null;
   }
 
@@ skipping 595 matching lines @@
       instruction = instruction.accept(this);
       instruction = next;
     }
   }
 
   HBoundsCheck insertBoundsCheck(HInstruction indexNode,
                                  HInstruction array,
                                  HInstruction indexArgument) {
     Compiler compiler = backend.compiler;
     HFieldGet length = new HFieldGet(
-        backend.jsIndexableLength, array, backend.intType,
+        backend.jsIndexableLength, array, backend.positiveIntType,
         isAssignable: !isFixedLength(array.instructionType, compiler));
     indexNode.block.addBefore(indexNode, length);
 
+    TypeMask type = indexArgument.isPositiveInteger(compiler)
+        ? indexArgument.instructionType
+        : backend.positiveIntType;
     HBoundsCheck check = new HBoundsCheck(
-        indexArgument, length, array, backend.intType);
+        indexArgument, length, array, type);
     indexNode.block.addBefore(indexNode, check);
     // If the index input to the bounds check was not known to be an integer
     // then we replace its uses with the bounds check, which is known to be an
     // integer.  However, if the input was already an integer we don't do this
     // because putting in a check instruction might obscure the real nature of
     // the index eg. if it is a constant.  The range information from the
     // BoundsCheck instruction is attached to the input directly by
     // visitBoundsCheck in the SsaValueRangeAnalyzer.
     if (!indexArgument.isInteger(compiler)) {
       indexArgument.replaceAllUsersDominatedBy(indexNode, check);
@@ skipping 1073 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }