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

sdk/lib/_internal/compiler/implementation/ssa/invoke_dynamic_specializers.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.
 
 part of ssa;
 
 /**
  * [InvokeDynamicSpecializer] and its subclasses are helpers to
  * optimize intercepted dynamic calls. It knows what input types
  * would be beneficial for performance, and how to change a invoke
@@ skipping 208 matching lines @@
     instruction.sideEffects.clearAllDependencies();
     instruction.setUseGvn();
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction, Compiler compiler);
 }
 
 class AddSpecializer extends BinaryArithmeticSpecializer {
   const AddSpecializer();
 
+  TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,

[kasperl, 2013/11/28 09:09:47]

Share this code between add, modulo, multiply, truncating divide.

[ngeoffray, 2013/11/28 11:21:47]

Done.

+                                     Compiler compiler) {
+    HInstruction left = instruction.inputs[1];
+    HInstruction right = instruction.inputs[2];
+    JavaScriptBackend backend = compiler.backend;
+    if (left.isPositiveIntegerOrNull(compiler)
+        && right.isPositiveIntegerOrNull(compiler)) {
+      return backend.positiveIntType;
+    }
+    return super.computeTypeFromInputTypes(instruction, compiler);
+  }
+
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.add;
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
     return new HAdd(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, computeTypeFromInputTypes(instruction, compiler));
   }
@@ skipping 21 matching lines @@
     JavaScriptBackend backend = compiler.backend;
     return new HDivide(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, backend.doubleType);
   }
 }
 
 class ModuloSpecializer extends BinaryArithmeticSpecializer {
   const ModuloSpecializer();
 
+  TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,
+                                     Compiler compiler) {
+    HInstruction left = instruction.inputs[1];
+    HInstruction right = instruction.inputs[2];
+    JavaScriptBackend backend = compiler.backend;
+    if (left.isPositiveIntegerOrNull(compiler)
+        && right.isPositiveIntegerOrNull(compiler)) {
+      return backend.positiveIntType;
+    }
+    return super.computeTypeFromInputTypes(instruction, compiler);
+  }
+
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.modulo;
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
     // Modulo cannot be mapped to the native operator (different semantics).
     return null;
   }
 }
 
 class MultiplySpecializer extends BinaryArithmeticSpecializer {
   const MultiplySpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.multiply;
   }
 
+  TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,
+                                     Compiler compiler) {
+    HInstruction left = instruction.inputs[1];
+    HInstruction right = instruction.inputs[2];
+    JavaScriptBackend backend = compiler.backend;
+    if (left.isPositiveIntegerOrNull(compiler)
+        && right.isPositiveIntegerOrNull(compiler)) {
+      return backend.positiveIntType;
+    }
+    return super.computeTypeFromInputTypes(instruction, compiler);
+  }
+
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
     return new HMultiply(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, computeTypeFromInputTypes(instruction, compiler));
   }
 }
 
 class SubtractSpecializer extends BinaryArithmeticSpecializer {
   const SubtractSpecializer();
@@ skipping 10 matching lines @@
   }
 }
 
 class TruncatingDivideSpecializer extends BinaryArithmeticSpecializer {
   const TruncatingDivideSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.truncatingDivide;
   }
 
+  TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,
+                                     Compiler compiler) {
+    HInstruction left = instruction.inputs[1];
+    HInstruction right = instruction.inputs[2];
+    JavaScriptBackend backend = compiler.backend;
+    if (left.isPositiveIntegerOrNull(compiler)
+        && right.isPositiveIntegerOrNull(compiler)) {
+      return backend.positiveIntType;
+    }
+    return super.computeTypeFromInputTypes(instruction, compiler);
+  }
+
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
     // Truncating divide does not have a JS equivalent.    
     return null;
   }
 }
 
 abstract class BinaryBitOpSpecializer extends BinaryArithmeticSpecializer {
   const BinaryBitOpSpecializer();
 
@@ skipping 13 matching lines @@
     if (!instruction.isConstantInteger()) return false;
     HConstant rightConstant = instruction;
     IntConstant intConstant = rightConstant.constant;
     int count = intConstant.value;
     return count >= 0 && count <= 31;
   }
 
   bool isPositive(HInstruction instruction, Compiler compiler) {
     // TODO: We should use the value range analysis. Currently, ranges
     // are discarded just after the analysis.
-    return instruction.isUInt32(compiler);
+    return instruction.isPositiveInteger(compiler);
   }
 }
 
 class ShiftLeftSpecializer extends BinaryBitOpSpecializer {
   const ShiftLeftSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.shiftLeft;
   }
 
@@ skipping 263 matching lines @@
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
     JavaScriptBackend backend = compiler.backend;
     return new HLessEqual(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, backend.boolType);
   }
 }