Always normalize a Range. The analysis does not work when it sees a range with unknown as bounds.

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;
 
@@ skipping 22 matching lines @@
   }
 
   Value newSubtractValue(Value left, Value right) {
     return new SubtractValue(left, right, this);
   }
 
   Value newNegateValue(Value value) {
     return new NegateValue(value, this);
   }
 
-  Range newRange(Value low, Value up) {
-    return new Range(low, up, this);
-  }
-
   Range newUnboundRange() {
     return new Range.unbound(this);
   }
 
   Range newNormalizedRange(Value low, Value up) {
     return new Range.normalize(low, up, this);
   }
 }
 
 /**
@@ skipping 363 matching lines @@
 
 /**
  * A [Range] represents the possible integer values an instruction
  * can have, from its [lower] bound to its [upper] bound, both
  * included.
  */
 class Range {
   final Value lower;
   final Value upper;
   final ValueRangeInfo info;
-  Range(this.lower, this.upper, this.info);
+  Range(this.lower, this.upper, this.info) {
+    assert(lower != const UnknownValue());
+    assert(upper != const UnknownValue());
+  }
 
   Range.unbound(info) : this(const MinIntValue(), const MaxIntValue(), info);
 
   /**
    * Checks if the given values are unknown, and creates a
    * range that does not have any unknown values.
    */
   Range.normalize(Value low, Value up, info) : this(
       low == const UnknownValue() ? const MinIntValue() : low,
       up == const UnknownValue() ? const MaxIntValue() : up,
@@ skipping 12 matching lines @@
     if (low == const UnknownValue()) {
       if (lower is IntValue) low = lower;
       else if (other.lower is IntValue) low = other.lower;
       else low = lower;
     }
     if (up == const UnknownValue()) {
       if (upper is IntValue) up = upper;
       else if (other.upper is IntValue) up = other.upper;
       else up = upper;
     }
-    return info.newRange(low, up);
+    return info.newNormalizedRange(low, up);
   }
 
   Range operator +(Range other) {
     return info.newNormalizedRange(lower + other.lower, upper + other.upper);
   }
 
   Range operator -(Range other) {
     return info.newNormalizedRange(lower - other.upper, upper - other.lower);
   }
 
   Range operator -() {
     return info.newNormalizedRange(-upper, -lower);
   }
 
   Range operator &(Range other) {
     if (isSingleValue
         && other.isSingleValue
         && lower is IntValue
         && other.lower is IntValue) {
-      return info.newRange(lower & other.lower, upper & other.upper);
+      return info.newNormalizedRange(lower & other.lower, upper & other.upper);
     }
     if (isPositive && other.isPositive) {
       Value up = upper.min(other.upper);
       if (up == const UnknownValue()) {
         // If we could not find a trivial bound, just try to use the
         // one that is an int.
         up = upper is IntValue ? upper : other.upper;
         // Make sure we get the same upper bound, whether it's a & b
         // or b & a.
         if (up is! IntValue && upper != other.upper) up = const MaxIntValue();
       }
-      return info.newRange(info.intZero, up);
+      return info.newNormalizedRange(info.intZero, up);
     } else if (isPositive) {
-      return info.newRange(info.intZero, upper);
+      return info.newNormalizedRange(info.intZero, upper);
     } else if (other.isPositive) {
-      return info.newRange(info.intZero, other.upper);
+      return info.newNormalizedRange(info.intZero, other.upper);
     } else {
       return info.newUnboundRange();
     }
   }
 
   bool operator ==(other) {
     if (other is! Range) return false;
     return other.lower == lower && other.upper == upper;
   }
 
@@ skipping 81 matching lines @@
     block.forEachInstruction(visit);
   }
 
   Range visitInstruction(HInstruction instruction) {
     return info.newUnboundRange();
   }
 
   Range visitParameterValue(HParameterValue parameter) {
     if (!parameter.isInteger()) return info.newUnboundRange();
     Value value = info.newInstructionValue(parameter);
-    return info.newRange(value, value);
+    return info.newNormalizedRange(value, value);
   }
 
   Range visitPhi(HPhi phi) {
     if (!phi.isInteger()) return info.newUnboundRange();
     if (phi.block.isLoopHeader()) {
       Range range = tryInferLoopPhiRange(phi);
       if (range == null) return info.newUnboundRange();
       return range;
     }
 
     Range range = ranges[phi.inputs[0]];
     for (int i = 1; i < phi.inputs.length; i++) {
       range = range.union(ranges[phi.inputs[i]]);
     }
     return range;
   }
 
   Range tryInferLoopPhiRange(HPhi phi) {
     HInstruction update = phi.inputs[1];
     return update.accept(new LoopUpdateRecognizer(phi, ranges, info));
   }
 
   Range visitConstant(HConstant constant) {
     if (!constant.isInteger()) return info.newUnboundRange();
     IntConstant constantInt = constant.constant;
     Value value = info.newIntValue(constantInt.value);
-    return info.newRange(value, value);
+    return info.newNormalizedRange(value, value);
   }
 
   Range visitFieldGet(HFieldGet fieldGet) {
     if (!fieldGet.isInteger()) return info.newUnboundRange();
     if (!fieldGet.receiver.isIndexablePrimitive()) {
       return visitInstruction(fieldGet);
     }
     LengthValue value = info.newLengthValue(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.newRange(info.intZero, value);
+    return info.newNormalizedRange(info.intZero, value);
   }
 
   Range visitBoundsCheck(HBoundsCheck check) {
     // Save the next instruction, in case the check gets removed.
     HInstruction next = check.next;
     Range indexRange = ranges[check.index];
     Range lengthRange = ranges[check.length];
     assert(check.index.isInteger());
     assert(check.length.isInteger());
 
@@ skipping 22 matching lines @@
       check.staticChecks = HBoundsCheck.ALWAYS_BELOW_LENGTH;
     }
 
     if (indexRange.isPositive) {
       // If the test passes, we know the lower bound of the length is
       // greater or equal than the lower bound of the index.
       Value low = lengthRange.lower.max(indexRange.lower);
       if (low != const UnknownValue()) {
         HInstruction instruction =
             createRangeConversion(next, check.length);
-        ranges[instruction] = info.newRange(low, lengthRange.upper);
+        ranges[instruction] = info.newNormalizedRange(low, lengthRange.upper);
       }
     }
 
     if (!belowLength) {
       // Update the range of the index if using the maximum index
       // narrows it.
       Range newIndexRange = indexRange.intersection(
-          info.newRange(info.intZero, maxIndex));
+          info.newNormalizedRange(info.intZero, maxIndex));
       if (indexRange == newIndexRange) return indexRange;
       HInstruction instruction = createRangeConversion(next, check.index);
       ranges[instruction] = newIndexRange;
       return newIndexRange;
     }
 
     return indexRange;
   }
 
   Range visitRelational(HRelational relational) {
@@ skipping 47 matching lines @@
     if (!node.isInteger()) return info.newUnboundRange();
     HInstruction right = node.right;
     HInstruction left = node.left;
     if (left.isInteger() && right.isInteger()) {
       return ranges[left] & ranges[right];
     }
 
     Range tryComputeRange(HInstruction instruction) {
       Range range = ranges[instruction];
       if (range.isPositive) {
-        return info.newRange(info.intZero, range.upper);
+        return info.newNormalizedRange(info.intZero, range.upper);
       } else if (range.isNegative) {
-        return info.newRange(range.lower, info.intZero);
+        return info.newNormalizedRange(range.lower, info.intZero);
       }
       return info.newUnboundRange();
     }
 
     if (left.isInteger()) {
       return tryComputeRange(left);
     } else if (right.isInteger()) {
       return tryComputeRange(right);
     }
     return info.newUnboundRange();
@@ skipping 32 matching lines @@
     } else {
       return null;
     }
   }
 
   Range computeConstrainedRange(BinaryOperation operation,
                                 Range leftRange,
                                 Range rightRange) {
     Range range;
     if (operation == const LessOperation()) {
-      range = info.newRange(
+      range = info.newNormalizedRange(
           const MinIntValue(), rightRange.upper - info.intOne);
     } else if (operation == const LessEqualOperation()) {
-      range = info.newRange(const MinIntValue(), rightRange.upper);
+      range = info.newNormalizedRange(const MinIntValue(), rightRange.upper);
     } else if (operation == const GreaterOperation()) {
-      range = info.newRange(
+      range = info.newNormalizedRange(
           rightRange.lower + info.intOne, const MaxIntValue());
     } else if (operation == const GreaterEqualOperation()) {
-      range = info.newRange(rightRange.lower, const MaxIntValue());
+      range = info.newNormalizedRange(rightRange.lower, const MaxIntValue());
     } else {
       range = info.newUnboundRange();
     }
     return range.intersection(leftRange);
   }
 
   Range visitConditionalBranch(HConditionalBranch branch) {
     var condition = branch.condition;
     // TODO(ngeoffray): Handle complex conditions.
     if (condition is !HRelational) return info.newUnboundRange();
@@ skipping 65 matching lines @@
   final HPhi loopPhi;
   final Map<HInstruction, Range> ranges;
   final ValueRangeInfo info;
   LoopUpdateRecognizer(this.loopPhi, this.ranges, this.info);
 
   Range visitAdd(HAdd operation) {
     Range range = getRangeForRecognizableOperation(operation);
     if (range == null) return info.newUnboundRange();
     Range initial = ranges[loopPhi.inputs[0]];
     if (range.isPositive) {
-      return info.newRange(initial.lower, const MaxIntValue());
+      return info.newNormalizedRange(initial.lower, const MaxIntValue());
     } else if (range.isNegative) {
-      return info.newRange(const MinIntValue(), initial.upper);
+      return info.newNormalizedRange(const MinIntValue(), initial.upper);
     }
     return info.newUnboundRange();
   }
 
   Range visitSubtract(HSubtract operation) {
     Range range = getRangeForRecognizableOperation(operation);
     if (range == null) return info.newUnboundRange();
     Range initial = ranges[loopPhi.inputs[0]];
     if (range.isPositive) {
-      return info.newRange(const MinIntValue(), initial.upper);
+      return info.newNormalizedRange(const MinIntValue(), initial.upper);
     } else if (range.isNegative) {
-      return info.newRange(initial.lower, const MaxIntValue());
+      return info.newNormalizedRange(initial.lower, const MaxIntValue());
     }
     return info.newUnboundRange();
   }
 
   Range visitPhi(HPhi phi) {
     Range phiRange;
     for (HInstruction input in phi.inputs) {
       HInstruction instruction = unwrap(input);
       // If one of the inputs is the loop phi, then we're only
       // interested in the other inputs: a loop phi feeding itself means
@@ skipping 29 matching lines @@
     if (!isLeftLoopPhi && !isRightLoopPhi) return null;
 
     var other = isLeftLoopPhi ? right : left;
     // If the analysis already computed range for the update, use it.
     if (ranges[other] != null) return ranges[other];
 
     // We currently only handle constants in updates if the
     // update does not have a range.
     if (other.isConstant()) {
       Value value = info.newIntValue(other.constant.value);
-      return info.newRange(value, value);
+      return info.newNormalizedRange(value, value);
     }
     return null;
   }
 
   /**
    * [HCheck] instructions may check the loop phi. Since we only
    * recognize updates on the loop phi, we must [unwrap] the [HCheck]
    * instruction to check if it references the loop phi.
    */
   HInstruction unwrap(instruction) {
     if (instruction is HCheck) return unwrap(instruction.checkedInput);
     // [HPhi] might have two different [HCheck] instructions as
     // inputs, checking the same instruction.
     if (instruction is HPhi && !instruction.block.isLoopHeader()) {
       HInstruction result = unwrap(instruction.inputs[0]);
       for (int i = 1; i < instruction.inputs.length; i++) {
         if (result != unwrap(instruction.inputs[i])) return instruction;
       }
       return result;
     }
     return instruction;
   }
 }