dart2js: Constant folding and specialization for remainder

pkg/compiler/lib/src/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.
 
 import '../constant_system_dart.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../js_backend/js_backend.dart';
 import '../js_backend/backend_helpers.dart';
 import '../world.dart' show ClosedWorld;
@@ skipping 796 matching lines @@
       node.block.rewrite(node, graph.addConstantBool(true, closedWorld));
       node.block.remove(node);
     }
   }
 
   Range handleInvokeModulo(HInvokeDynamicMethod invoke) {
     HInstruction left = invoke.inputs[1];
     HInstruction right = invoke.inputs[2];
     Range divisor = ranges[right];
     if (divisor != null) {
-      // For Integer values we can be precise in the upper bound,
-      // so special case those.
+      // For Integer values we can be precise in the upper bound, so special
+      // case those.
       if (left.isInteger(closedWorld) && right.isInteger(closedWorld)) {
         if (divisor.isPositive) {
           return info.newNormalizedRange(
               info.intZero, divisor.upper - info.intOne);
         } else if (divisor.isNegative) {
           return info.newNormalizedRange(
               info.intZero, info.newNegateValue(divisor.lower) - info.intOne);
         }
       } else if (left.isNumber(closedWorld) && right.isNumber(closedWorld)) {
         if (divisor.isPositive) {
           return info.newNormalizedRange(info.intZero, divisor.upper);
         } else if (divisor.isNegative) {
           return info.newNormalizedRange(
               info.intZero, info.newNegateValue(divisor.lower));
         }
       }
     }
     return info.newUnboundRange();
   }
 
+  Range visitRemainder(HRemainder instruction) {
+    HInstruction left = instruction.inputs[0];
+    HInstruction right = instruction.inputs[1];
+    Range dividend = ranges[left];
+    // If both operands are >=0, the result is >= 0 and bounded by the divisor.
+    if ((dividend != null && dividend.isPositive) ||
+        left.isPositiveInteger(closedWorld)) {
+      Range divisor = ranges[right];
+      if (divisor != null) {
+        if (divisor.isPositive) {
+          // For Integer values we can be precise in the upper bound.
+          if (left.isInteger(closedWorld) && right.isInteger(closedWorld)) {
+            return info.newNormalizedRange(
+                info.intZero, divisor.upper - info.intOne);
+          }
+          if (left.isNumber(closedWorld) && right.isNumber(closedWorld)) {
+            return info.newNormalizedRange(info.intZero, divisor.upper);
+          }
+        }
+      }
+    }
+    return info.newUnboundRange();
+  }
+
   Range visitInvokeDynamicMethod(HInvokeDynamicMethod invoke) {
     if ((invoke.inputs.length == 3) && (invoke.selector.name == "%"))
       return handleInvokeModulo(invoke);
     return super.visitInvokeDynamicMethod(invoke);
   }
 
   Range handleBinaryOperation(HBinaryArithmetic instruction) {
     if (!instruction.isInteger(closedWorld)) return info.newUnboundRange();
     return instruction
         .operation(constantSystem)
@@ skipping 233 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);
   }
 }