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

sdk/lib/_internal/compiler/implementation/ssa/types_propagation.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 SsaTypePropagator extends HBaseVisitor implements OptimizationPhase {
   final Map<int, HInstruction> workmap = new Map<int, HInstruction>();
   final List<int> worklist = new List<int>();
   final Map<HInstruction, Function> pendingOptimizations =
@@ skipping 89 matching lines @@
     HInstruction left = instruction.left;
     HInstruction right = instruction.right;
     JavaScriptBackend backend = compiler.backend;    
     if (left.isInteger(compiler) && right.isInteger(compiler)) {
       return backend.intType;
     }
     if (left.isDouble(compiler)) return backend.doubleType;
     return backend.numType;
   }
 
+  TypeMask checkPositiveInteger(HBinaryArithmetic instruction) {
+    HInstruction left = instruction.left;
+    HInstruction right = instruction.right;
+    JavaScriptBackend backend = compiler.backend;    
+    if (left.isPositiveInteger(compiler) && right.isPositiveInteger(compiler)) {
+      return backend.positiveIntType;
+    }
+    return visitBinaryArithmetic(instruction);
+  }
+
+  TypeMask visitMultiply(HMultiply instruction) {
+    return checkPositiveInteger(instruction);
+  }
+
+  TypeMask visitAdd(HAdd instruction) {
+    return checkPositiveInteger(instruction);
+  }
+
   TypeMask visitNegate(HNegate instruction) {
     return instruction.operand.instructionType;
   }
 
   TypeMask visitInstruction(HInstruction instruction) {
     assert(instruction.instructionType != null);
     return instruction.instructionType;
   }
 
   TypeMask visitPhi(HPhi phi) {
@@ skipping 122 matching lines @@
     // We want the right error in checked mode.
     if (compiler.enableTypeAssertions) return false;
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
 
     Selector selector = instruction.selector;
     if (selector.isOperator() && left.isNumber(compiler)) {
       if (right.isNumber(compiler)) return false;
       JavaScriptBackend backend = compiler.backend;    
       TypeMask type = right.isIntegerOrNull(compiler)
-          ? backend.intType
+          ? right.instructionType.nonNullable()
           : backend.numType;
       // TODO(ngeoffray): Some number operations don't have a builtin
       // variant and will do the check in their method anyway. We
       // still add a check because it allows to GVN these operations,
       // but we should find a better way.
       convertInput(instruction,
                    right,
                    type,
                    HTypeConversion.ARGUMENT_TYPE_CHECK);
       return true;
@@ skipping 66 matching lines @@
         instruction.block.addBefore(instruction.next, converted);
         receiver.replaceAllUsersDominatedBy(converted.next, converted);
         addDependentInstructionsToWorkList(converted);
       }
     }
 
     return instruction.specializer.computeTypeFromInputTypes(
         instruction, compiler);
   }
 }