isEven, isOdd, isNegative, isMaxValue, isMinValue, isInfinite, isPositive, isSingleValue.

lib/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.
 
 /**
  * A [Value] represents both symbolic values like the value of a
  * parameter, or the length of an array, and concrete values, like
  * constants.
  */
 abstract class Value {
   const Value();
 
   Value operator +(Value other);
   Value operator -(Value other);
   Value operator -();
   Value operator &(Value other);
 
   Value min(Value other) {
     if (this == other) return this;
     if (other == const MinIntValue()) return other;
     if (other == const MaxIntValue()) return this;
     Value value = this - other;
-    if (value.isPositive()) return other;
-    if (value.isNegative()) return this;
+    if (value.isPositive) return other;
+    if (value.isNegative) return this;
     return const UnknownValue();
   }
 
   Value max(Value other) {
     if (this == other) return this;
     if (other == const MinIntValue()) return this;
     if (other == const MaxIntValue()) return other;
     Value value = this - other;
-    if (value.isPositive()) return this;
-    if (value.isNegative()) return other;
+    if (value.isPositive) return this;
+    if (value.isNegative) return other;
     return const UnknownValue();
   }
 
-  bool isNegative() => false;
-  bool isPositive() => false;
-  bool isZero() => false;
+  bool get isNegative => false;
+  bool get isPositive => false;
+  bool get isZero => false;
 }
 
 /**
  * An [IntValue] contains a constant integer value.
  */
 class IntValue extends Value {
   final int value;
   const IntValue(this.value);
 
   Value operator +(other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     if (other is !IntValue) return other + this;
     return new IntValue(value + other.value);
   }
 
   Value operator -(other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     if (other is !IntValue) return -other + this;
     return new IntValue(value - other.value);
   }
 
   Value operator -() {
-    if (isZero()) return this;
+    if (isZero) return this;
     return new IntValue(-value);
   }
 
   Value operator &(other) {
     if (other is !IntValue) {
-      if (isPositive()) return this;
-      if (other.isPositive()) return new IntValue(-value);
+      if (isPositive) return this;
+      if (other.isPositive) return new IntValue(-value);
       return const UnknownValue();
     }
     return new IntValue(value & other.value);
   }
 
   Value min(other) {
     if (other is !IntValue) return other.min(this);
     return this.value < other.value ? this : other;
   }
 
   Value max(other) {
     if (other is !IntValue) return other.max(this);
     return this.value < other.value ? other : this;
   }
 
   bool operator ==(other) {
     if (other is !IntValue) return false;
     return this.value == other.value;
   }
 
   String toString() => 'IntValue $value';
-  bool isNegative() => value < 0;
-  bool isPositive() => value >= 0;
-  bool isZero() => value == 0;
+  bool get isNegative => value < 0;
+  bool get isPositive => value >= 0;
+  bool get isZero => value == 0;
 }
 
 /**
  * The [MaxIntValue] represents the maximum value an integer can have,
  * which is currently +infinity.
  */
 class MaxIntValue extends Value {
   const MaxIntValue();
   Value operator +(Value other) => this;
   Value operator -(Value other) => this;
   Value operator -() => const MinIntValue();
   Value operator &(Value other) {
-    if (other.isPositive()) return other;
-    if (other.isNegative()) return const IntValue(0);
+    if (other.isPositive) return other;
+    if (other.isNegative) return const IntValue(0);
     return this;
   }
   Value min(Value other) => other;
   Value max(Value other) => this;
   String toString() => 'Max';
-  bool isNegative() => false;
-  bool isPositive() => true;
+  bool get isNegative => false;
+  bool get isPositive => true;
 }
 
 /**
  * The [MinIntValue] represents the minimum value an integer can have,
  * which is currently -infinity.
  */
 class MinIntValue extends Value {
   const MinIntValue();
   Value operator +(Value other) => this;
   Value operator -(Value other) => this;
   Value operator -() => const MaxIntValue();
   Value operator &(Value other) {
-    if (other.isPositive()) return const IntValue(0);
+    if (other.isPositive) return const IntValue(0);
     return this;
   }
   Value min(Value other) => this;
   Value max(Value other) => other;
   String toString() => 'Min';
-  bool isNegative() => true;
-  bool isPositive() => false;
+  bool get isNegative => true;
+  bool get isPositive => false;
 }
 
 /**
  * The [UnknownValue] is the sentinel in our analysis to mark an
  * operation that could not be done because of too much complexity.
  */
 class UnknownValue extends Value {
   const UnknownValue();
   Value operator +(Value other) => const UnknownValue();
   Value operator -(Value other) => const UnknownValue();
   Value operator -() => const UnknownValue();
   Value operator &(Value other) => const UnknownValue();
   Value min(Value other) => const UnknownValue();
   Value max(Value other) => const UnknownValue();
-  bool isNegative() => false;
-  bool isPositive() => false;
+  bool get isNegative => false;
+  bool get isPositive => false;
   String toString() => 'Unknown';
 }
 
 /**
  * A symbolic value representing an [HInstruction].
  */
 class InstructionValue extends Value {
   final HInstruction instruction;
   InstructionValue(this.instruction);
 
   bool operator ==(other) {
     if (other is !InstructionValue) return false;
     return this.instruction == other.instruction;
   }
 
   Value operator +(Value other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     if (other is IntValue) {
-      if (other.isNegative()) {
+      if (other.isNegative) {
         return new SubtractValue(this, -other);
       }
       return new AddValue(this, other);
     }
     if (other is InstructionValue) {
       return new AddValue(this, other);
     }
     return other + this;
   }
 
   Value operator -(Value other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     if (this == other) return const IntValue(0);
     if (other is IntValue) {
-      if (other.isNegative()) {
+      if (other.isNegative) {
         return new AddValue(this, -other);
       }
       return new SubtractValue(this, other);
     }
     if (other is InstructionValue) {
       return new SubtractValue(this, other);
     }
     return -other + this;
   }
 
   Value operator -() {
     return new NegateValue(this);
   }
 
   Value operator &(Value other) {
     if (other is IntValue) return other & this;
     return this;
   }
 
-  bool isNegative() => false;
-  bool isPositive() => false;
+  bool get isNegative => false;
+  bool get isPositive => false;
 
   String toString() => 'Instruction: $instruction';
 }
 
 /**
  * Special value for instructions that represent the length of an
  * array. The difference with an [InstructionValue] is that we know
  * the value is positive.
  */
 class LengthValue extends InstructionValue {
   LengthValue(HInstruction instruction) : super(instruction);
-  bool isPositive() => true;
+  bool get isPositive => true;
   String toString() => 'Length: $instruction';
 }
 
 /**
  * Represents a binary operation on two [Value], where the operation
  * did not yield a canonical value.
  */
 class OperationValue extends Value {
   Operation operation;
 }
@@ skipping 10 matching lines @@
   bool operator ==(other) {
     if (other is !AddValue) return false;
     return (left == other.left && right == other.right)
       || (left == other.right && right == other.left);
   }
 
   Value operator &(Value other) => const UnknownValue();
   Value operator -() => -left - right;
 
   Value operator +(Value other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     Value value = left + other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return value + right;
     }
     // If the result is not simple enough, we try the same approach
     // with [right].
     value = right + other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return left + value;
     }
     return const UnknownValue();
   }
 
   Value operator -(Value other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     Value value = left - other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return value + right;
     }
     // If the result is not simple enough, we try the same approach
     // with [right].
     value = right - other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return left + value;
     }
     return const UnknownValue();
   }
 
-  bool isNegative() => left.isNegative() && right.isNegative();
-  bool isPositive() => left.isPositive() && right.isPositive();
+  bool get isNegative => left.isNegative && right.isNegative;
+  bool get isPositive => left.isPositive && right.isPositive;
   String toString() => '$left + $right';
 }
 
 class SubtractValue extends BinaryOperationValue {
   SubtractValue(left, right) : super(left, right);
 
   bool operator ==(other) {
     if (other is !SubtractValue) return false;
     return left == other.left && right == other.right;
   }
 
   Value operator &(Value other) => const UnknownValue();
   Value operator -() => right - left;
 
   Value operator +(Value other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     Value value = left + other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return value - right;
     }
     // If the result is not simple enough, we try the same approach
     // with [right].
     value = other - right;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return left + value;
     }
     return const UnknownValue();
   }
 
   Value operator -(Value other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     Value value = left - other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return value - right;
     }
     // If the result is not simple enough, we try the same approach
     // with [right].
     value = right + other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
       return left - value;
     }
     return const UnknownValue();
   }
 
-  bool isNegative() => left.isNegative() && right.isPositive();
-  bool isPositive() => left.isPositive() && right.isNegative();
+  bool get isNegative => left.isNegative && right.isPositive;
+  bool get isPositive => left.isPositive && right.isNegative;
   String toString() => '$left - $right';
 }
 
 class NegateValue extends OperationValue {
   final Value value;
   NegateValue(this.value);
 
   bool operator ==(other) {
     if (other is !NegateValue) return false;
     return value == other.value;
   }
 
   Value operator +(other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     if (other == value) return const IntValue(0);
     if (other is NegateValue) return this - other.value;
     if (other is IntValue) {
-      if (other.isNegative()) {
+      if (other.isNegative) {
         return new SubtractValue(this, -other);
       }
       return new SubtractValue(other, value);
     }
     if (other is InstructionValue) {
       return new SubtractValue(other, value);
     }
     return other - value;
   }
 
   Value operator &(Value other) => const UnknownValue();
 
   Value operator -(other) {
-    if (other.isZero()) return this;
+    if (other.isZero) return this;
     if (other is IntValue) {
-      if (other.isNegative()) {
+      if (other.isNegative) {
         return new SubtractValue(-other, value);
       }
       return new SubtractValue(this, other);
     }
     if (other is InstructionValue) {
       return new SubtractValue(this, other);
     }
     if (other is NegateValue) return this + other.value;
     return -other - value;
   }
 
   Value operator -() => value;
 
-  bool isNegative() => value.isPositive();
-  bool isPositive() => value.isNegative();
+  bool get isNegative => value.isPositive;
+  bool get isPositive => value.isNegative;
   String toString() => '-$value';
 }
 
 /**
  * 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;
@@ skipping 38 matching lines @@
 
   Range operator -(Range other) {
     return new Range.normalize(lower - other.upper, upper - other.lower);
   }
 
   Range operator -() {
     return new Range.normalize(-upper, -lower);
   }
 
   Range operator &(Range other) {
-    if (isSingleValue()
-        && other.isSingleValue()
+    if (isSingleValue
+        && other.isSingleValue
         && lower is IntValue
         && other.lower is IntValue) {
       return new Range(lower & other.lower, upper & other.upper);
     }
-    if (isPositive() && other.isPositive()) {
+    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 new Range(const IntValue(0), up);
-    } else if (isPositive()) {
+    } else if (isPositive) {
       return new Range(const IntValue(0), upper);
-    } else if (other.isPositive()) {
+    } else if (other.isPositive) {
       return new Range(const IntValue(0), other.upper);
     } else {
       return const Range.unbound();
     }
   }
 
   bool operator ==(other) {
     if (other is! Range) return false;
     return other.lower == lower && other.upper == upper;
   }
 
   bool operator <(Range other) {
     return upper != other.lower && upper.min(other.lower) == upper;
   }
 
   bool operator >(Range other) {
     return lower != other.upper && lower.max(other.upper) == lower;
   }
 
   bool operator <=(Range other) {
     return upper.min(other.lower) == upper;
   }
 
   bool operator >=(Range other) {
     return lower.max(other.upper) == lower;
   }
 
-  bool isNegative() => upper.isNegative();
-  bool isPositive() => lower.isPositive();
-  bool isSingleValue() => lower == upper;
+  bool get isNegative => upper.isNegative;
+  bool get isPositive => lower.isPositive;
+  bool get isSingleValue => lower == upper;
 
   String toString() => '[$lower, $upper]';
 }
 
 /**
  * Visits the graph in dominator order, and computes value ranges for
  * integer instructions. While visiting the graph, this phase also
  * removes unnecessary bounds checks, and comparisons that are proven
  * to be true or false.
  */
@@ skipping 109 matching lines @@
     // range.
     Value maxIndex = lengthRange.upper - const IntValue(1);
     bool belowLength = maxIndex != const MaxIntValue()
         && indexRange.upper.min(maxIndex) == indexRange.upper;
 
     // Check if the index is strictly below the lower bound of the length
     // range.
     belowLength = belowLength
         || (indexRange.upper != lengthRange.lower
             && indexRange.upper.min(lengthRange.lower) == indexRange.upper);
-    if (indexRange.isPositive() && belowLength) {
+    if (indexRange.isPositive && belowLength) {
       check.block.rewrite(check, check.index);
       check.block.remove(check);
-    } else if (indexRange.isNegative() || lengthRange < indexRange) {
+    } else if (indexRange.isNegative || lengthRange < indexRange) {
       check.staticChecks = HBoundsCheck.ALWAYS_FALSE;
       // The check is always false, and whatever instruction it
       // dominates is dead code.
       return indexRange;
-    } else if (indexRange.isPositive()) {
+    } else if (indexRange.isPositive) {
       check.staticChecks = HBoundsCheck.ALWAYS_ABOVE_ZERO;
     } else if (belowLength) {
       check.staticChecks = HBoundsCheck.ALWAYS_BELOW_LENGTH;
     }
 
-    if (indexRange.isPositive()) {
+    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] = new Range(low, lengthRange.upper);
       }
     }
 
@@ skipping 30 matching lines @@
       relational.block.rewrite(
           relational, graph.addConstantBool(false, constantSystem));
       relational.block.remove(relational);
     }
     return const Range.unbound();
   }
 
   void handleEqualityCheck(HRelational node) {
     Range right = ranges[node.right];
     Range left = ranges[node.left];
-    if (left.isSingleValue() && right.isSingleValue() && left == right) {
+    if (left.isSingleValue && right.isSingleValue && left == right) {
       node.block.rewrite(
           node, graph.addConstantBool(true, constantSystem));
       node.block.remove(node);
     }
   }
 
   Range handleBinaryOperation(HBinaryArithmetic instruction) {
     if (!instruction.isInteger(types)) return const Range.unbound();
     return instruction.operation(constantSystem).apply(
         ranges[instruction.left], ranges[instruction.right]);
@@ skipping 10 matching lines @@
   Range visitBitAnd(HBitAnd node) {
     if (!node.isInteger(types)) return const Range.unbound();
     HInstruction right = node.right;
     HInstruction left = node.left;
     if (left.isInteger(types) && right.isInteger(types)) {
       return ranges[left] & ranges[right];
     }
 
     Range tryComputeRange(HInstruction instruction) {
       Range range = ranges[instruction];
-      if (range.isPositive()) {
+      if (range.isPositive) {
         return new Range(const IntValue(0), range.upper);
-      } else if (range.isNegative()) {
+      } else if (range.isNegative) {
         return new Range(range.lower, const IntValue(0));
       }
       return const Range.unbound();
     }
 
     if (left.isInteger(types)) {
       return tryComputeRange(left);
     } else if (right.isInteger(types)) {
       return tryComputeRange(right);
     }
@@ skipping 127 matching lines @@
 class LoopUpdateRecognizer extends HBaseVisitor {
   final HPhi loopPhi;
   final Map<HInstruction, Range> ranges;
   final HTypeMap types;
   LoopUpdateRecognizer(this.loopPhi, this.ranges, this.types);
 
   Range visitAdd(HAdd operation) {
     Range range = getRangeForRecognizableOperation(operation);
     if (range == null) return const Range.unbound();
     Range initial = ranges[loopPhi.inputs[0]];
-    if (range.isPositive()) {
+    if (range.isPositive) {
       return new Range(initial.lower, const MaxIntValue());
-    } else if (range.isNegative()) {
+    } else if (range.isNegative) {
       return new Range(const MinIntValue(), initial.upper);
     }
     return const Range.unbound();
   }
 
   Range visitSubtract(HSubtract operation) {
     Range range = getRangeForRecognizableOperation(operation);
     if (range == null) return const Range.unbound();
     Range initial = ranges[loopPhi.inputs[0]];
-    if (range.isPositive()) {
+    if (range.isPositive) {
       return new Range(const MinIntValue(), initial.upper);
-    } else if (range.isNegative()) {
+    } else if (range.isNegative) {
       return new Range(initial.lower, const MaxIntValue());
     }
     return const Range.unbound();
   }
 
   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
@@ skipping 54 matching lines @@
     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;
   }
 }