dartfmt pkg/compiler

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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../compiler.dart' show Compiler;
 import '../constant_system_dart.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../js_backend/js_backend.dart';
@@ skipping 38 matching lines @@
 
   Range newUnboundRange() {
     return new Range.unbound(this);
   }
 
   Range newNormalizedRange(Value low, Value up) {
     return new Range.normalize(low, up, this);
   }
 
   Range newMarkerRange() {
-    return new Range(new MarkerValue(false, this),
-                     new MarkerValue(true, this),
-                     this);
+    return new Range(
+        new MarkerValue(false, this), new MarkerValue(true, this), this);
   }
 }
 
 /**
  * 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 {
   final ValueRangeInfo info;
   const Value(this.info);
 
   Value operator +(Value other) => const UnknownValue();
   Value operator -(Value other) => const UnknownValue();
-  Value operator -()  => const UnknownValue();
+  Value operator -() => const UnknownValue();
   Value operator &(Value other) => const UnknownValue();
 
   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;
     return const UnknownValue();
@@ skipping 44 matching lines @@
 /**
  * An [IntValue] contains a constant integer value.
  */
 class IntValue extends Value {
   final int value;
 
   const IntValue(this.value, info) : super(info);
 
   Value operator +(other) {
     if (other.isZero) return this;
-    if (other is !IntValue) return other + this;
+    if (other is! IntValue) return other + this;
     ConstantSystem constantSystem = info.constantSystem;
     var constant = constantSystem.add.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     if (!constant.isInt) return const UnknownValue();
     return info.newIntValue(constant.primitiveValue);
   }
 
   Value operator -(other) {
     if (other.isZero) return this;
-    if (other is !IntValue) return -other + this;
+    if (other is! IntValue) return -other + this;
     ConstantSystem constantSystem = info.constantSystem;
     var constant = constantSystem.subtract.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     if (!constant.isInt) return const UnknownValue();
     return info.newIntValue(constant.primitiveValue);
   }
 
   Value operator -() {
     if (isZero) return this;
     ConstantSystem constantSystem = info.constantSystem;
-    var constant = constantSystem.negate.fold(
-        constantSystem.createInt(value));
+    var constant = constantSystem.negate.fold(constantSystem.createInt(value));
     if (!constant.isInt) return const UnknownValue();
     return info.newIntValue(constant.primitiveValue);
   }
 
   Value operator &(other) {
-    if (other is !IntValue) return const UnknownValue();
+    if (other is! IntValue) return const UnknownValue();
     ConstantSystem constantSystem = info.constantSystem;
     var constant = constantSystem.bitAnd.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     return info.newIntValue(constant.primitiveValue);
   }
 
   Value min(other) {
-    if (other is !IntValue) return other.min(this);
+    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);
+    if (other is! IntValue) return other.max(this);
     return this.value < other.value ? other : this;
   }
 
   bool operator ==(other) {
-    if (other is !IntValue) return false;
+    if (other is! IntValue) return false;
     return this.value == other.value;
   }
 
   int get hashCode => throw new UnsupportedError('IntValue.hashCode');
 
   String toString() => 'IntValue $value';
   bool get isNegative => value < 0;
   bool get isPositive => value >= 0;
   bool get isZero => value == 0;
 }
@@ skipping 47 matching lines @@
 }
 
 /**
  * A symbolic value representing an [HInstruction].
  */
 class InstructionValue extends Value {
   final HInstruction instruction;
   InstructionValue(this.instruction, info) : super(info);
 
   bool operator ==(other) {
-    if (other is !InstructionValue) return false;
+    if (other is! InstructionValue) return false;
     return this.instruction == other.instruction;
   }
 
   int get hashCode => throw new UnsupportedError('InstructionValue.hashCode');
 
   Value operator +(Value other) {
     if (other.isZero) return this;
     if (other is IntValue) {
       if (other.isNegative) {
         return info.newSubtractValue(this, -other);
@@ skipping 46 matching lines @@
 class BinaryOperationValue extends Value {
   final Value left;
   final Value right;
   BinaryOperationValue(this.left, this.right, info) : super(info);
 }
 
 class AddValue extends BinaryOperationValue {
   AddValue(left, right, info) : super(left, right, info);
 
   bool operator ==(other) {
-    if (other is !AddValue) return false;
-    return (left == other.left && right == other.right)
-      || (left == other.right && right == other.left);
+    if (other is! AddValue) return false;
+    return (left == other.left && right == other.right) ||
+        (left == other.right && right == other.left);
   }
 
   int get hashCode => throw new UnsupportedError('AddValue.hashCode');
 
   Value operator -() => -left - right;
 
   Value operator +(Value other) {
     if (other.isZero) return this;
     Value value = left + other;
     if (value != const UnknownValue() && value is! BinaryOperationValue) {
@@ skipping 25 matching lines @@
 
   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, info) : super(left, right, info);
 
   bool operator ==(other) {
-    if (other is !SubtractValue) return false;
+    if (other is! SubtractValue) return false;
     return left == other.left && right == other.right;
   }
 
   int get hashCode => throw new UnsupportedError('SubtractValue.hashCode');
 
   Value operator -() => right - left;
 
   Value operator +(Value other) {
     if (other.isZero) return this;
     Value value = left + other;
@@ skipping 27 matching lines @@
   bool get isNegative => left.isNegative && right.isPositive;
   bool get isPositive => left.isPositive && right.isNegative;
   String toString() => '$left - $right';
 }
 
 class NegateValue extends Value {
   final Value value;
   NegateValue(this.value, info) : super(info);
 
   bool operator ==(other) {
-    if (other is !NegateValue) return false;
+    if (other is! NegateValue) return false;
     return value == other.value;
   }
 
   int get hashCode => throw new UnsupportedError('Negate.hashCode');
 
   Value operator +(other) {
     if (other.isZero) return this;
     if (other == value) return info.intZero;
     if (other is NegateValue) return this - other.value;
     if (other is IntValue) {
@@ skipping 45 matching lines @@
     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,
-      info);
+  Range.normalize(Value low, Value up, info)
+      : this(low == const UnknownValue() ? const MinIntValue() : low,
+            up == const UnknownValue() ? const MaxIntValue() : up, info);
 
   Range union(Range other) {
     return info.newNormalizedRange(
         lower.min(other.lower), upper.max(other.upper));
   }
 
   Range intersection(Range other) {
     Value low = lower.max(other.lower);
     Value up = upper.min(other.upper);
     // If we could not compute max or min, pick a value in the two
     // ranges, with priority to [IntValue]s because they are simpler.
     if (low == const UnknownValue()) {
-      if (lower is IntValue) low = lower;
-      else if (other.lower is IntValue) low = other.lower;
-      else low = lower;
+      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;
+      if (upper is IntValue)
+        up = upper;
+      else if (other.upper is IntValue)
+        up = other.upper;
+      else
+        up = upper;
     }
     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) {
+    if (isSingleValue &&
+        other.isSingleValue &&
+        lower is IntValue &&
+        other.lower is IntValue) {
       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.
@@ skipping 61 matching lines @@
   final Map<HInstruction, Range> ranges = new Map<HInstruction, Range>();
 
   final Compiler compiler;
   final ConstantSystem constantSystem;
   final ValueRangeInfo info;
   final SsaOptimizerTask optimizer;
 
   CodegenWorkItem work;
   HGraph graph;
 
-  SsaValueRangeAnalyzer(this.compiler,
-                        constantSystem,
-                        this.optimizer,
-                        this.work)
+  SsaValueRangeAnalyzer(
+      this.compiler, constantSystem, this.optimizer, this.work)
       : info = new ValueRangeInfo(constantSystem),
         this.constantSystem = constantSystem;
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
     visitDominatorTree(graph);
     // We remove the range conversions after visiting the graph so
     // that the graph does not get polluted with these instructions
     // only necessary for this phase.
     removeRangeConversion();
     // TODO(herhut): Find a cleaner way to pass around ranges.
     optimizer.ranges = ranges;
   }
 
   void removeRangeConversion() {
     conversions.forEach((HRangeConversion instruction) {
       instruction.block.rewrite(instruction, instruction.inputs[0]);
       instruction.block.remove(instruction);
     });
   }
 
   void visitBasicBlock(HBasicBlock block) {
-
     void visit(HInstruction instruction) {
       Range range = instruction.accept(this);
       if (instruction.isInteger(compiler)) {
         assert(range != null);
         ranges[instruction] = range;
       }
     }
 
     block.forEachPhi(visit);
     block.forEachInstruction(visit);
@@ skipping 78 matching lines @@
       // We might have lost the length range due to a type conversion that
       // asserts a non-integer type. In such a case, the program will never
       // get to this point anyway, so no need to try and refine ranges.
       return indexRange;
     }
     assert(check.length.isInteger(compiler));
 
     // Check if the index is strictly below the upper bound of the length
     // range.
     Value maxIndex = lengthRange.upper - info.intOne;
-    bool belowLength = maxIndex != const MaxIntValue()
-        && indexRange.upper.min(maxIndex) == indexRange.upper;
+    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);
+    belowLength = belowLength ||
+        (indexRange.upper != lengthRange.lower &&
+            indexRange.upper.min(lengthRange.lower) == indexRange.upper);
     if (indexRange.isPositive && belowLength) {
       check.block.rewrite(check, check.index);
       check.block.remove(check);
     } 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) {
       check.staticChecks = HBoundsCheck.ALWAYS_ABOVE_ZERO;
     } else if (belowLength) {
       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);
+        HInstruction instruction = createRangeConversion(next, check.length);
         ranges[instruction] = info.newNormalizedRange(low, lengthRange.upper);
       }
     }
 
     // Update the range of the index if using the maximum index
     // narrows it. Use that new range for this instruction as well.
-    Range newIndexRange = indexRange.intersection(
-        info.newNormalizedRange(info.intZero, maxIndex));
+    Range newIndexRange = indexRange
+        .intersection(info.newNormalizedRange(info.intZero, maxIndex));
     if (indexRange == newIndexRange) return indexRange;
     // Explicitly attach the range information to the index instruction,
     // which may be used by other instructions.  Returning the new range will
     // attach it to this instruction.
     HInstruction instruction = createRangeConversion(next, check.index);
     ranges[instruction] = newIndexRange;
     return newIndexRange;
   }
 
   Range visitRelational(HRelational relational) {
     HInstruction right = relational.right;
     HInstruction left = relational.left;
     if (!left.isInteger(compiler)) return info.newUnboundRange();
     if (!right.isInteger(compiler)) return info.newUnboundRange();
     BinaryOperation operation = relational.operation(constantSystem);
     Range rightRange = ranges[relational.right];
     Range leftRange = ranges[relational.left];
 
     if (relational is HIdentity) {
       handleEqualityCheck(relational);
     } else if (operation.apply(leftRange, rightRange)) {
-      relational.block.rewrite(
-          relational, graph.addConstantBool(true, compiler));
+      relational.block
+          .rewrite(relational, graph.addConstantBool(true, compiler));
       relational.block.remove(relational);
     } else if (negateOperation(operation).apply(leftRange, rightRange)) {
-      relational.block.rewrite(
-          relational, graph.addConstantBool(false, compiler));
+      relational.block
+          .rewrite(relational, graph.addConstantBool(false, compiler));
       relational.block.remove(relational);
     }
     return info.newUnboundRange();
   }
 
   void handleEqualityCheck(HRelational node) {
     Range right = ranges[node.right];
     Range left = ranges[node.left];
     if (left.isSingleValue && right.isSingleValue && left == right) {
-      node.block.rewrite(
-          node, graph.addConstantBool(true, compiler));
+      node.block.rewrite(node, graph.addConstantBool(true, compiler));
       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.
       if (left.isInteger(compiler) && right.isInteger(compiler)) {
         if (divisor.isPositive) {
-          return info.newNormalizedRange(info.intZero, divisor.upper -
-              info.intOne);
+          return info.newNormalizedRange(
+              info.intZero, divisor.upper - info.intOne);
         } else if (divisor.isNegative) {
-          return info.newNormalizedRange(info.intZero, info.newNegateValue(
-              divisor.lower) - info.intOne);
+          return info.newNormalizedRange(
+              info.intZero, info.newNegateValue(divisor.lower) - info.intOne);
         }
       } else if (left.isNumber(compiler) && right.isNumber(compiler)) {
         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.newNormalizedRange(
+              info.intZero, info.newNegateValue(divisor.lower));
         }
       }
     }
     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(compiler)) return info.newUnboundRange();
-    return instruction.operation(constantSystem).apply(
-        ranges[instruction.left], ranges[instruction.right]);
+    return instruction
+        .operation(constantSystem)
+        .apply(ranges[instruction.left], ranges[instruction.right]);
   }
 
   Range visitAdd(HAdd add) {
     return handleBinaryOperation(add);
   }
 
   Range visitSubtract(HSubtract sub) {
     return handleBinaryOperation(sub);
   }
 
@@ skipping 23 matching lines @@
     return info.newUnboundRange();
   }
 
   Range visitCheck(HCheck instruction) {
     if (ranges[instruction.checkedInput] == null) {
       return visitInstruction(instruction);
     }
     return ranges[instruction.checkedInput];
   }
 
-  HInstruction createRangeConversion(HInstruction cursor,
-                                     HInstruction instruction) {
+  HInstruction createRangeConversion(
+      HInstruction cursor, HInstruction instruction) {
     JavaScriptBackend backend = compiler.backend;
     HRangeConversion newInstruction =
         new HRangeConversion(instruction, backend.intType);
     conversions.add(newInstruction);
     cursor.block.addBefore(cursor, newInstruction);
     // Update the users of the instruction dominated by [cursor] to
     // use the new instruction, that has an narrower range.
     instruction.replaceAllUsersDominatedBy(cursor, newInstruction);
     return newInstruction;
   }
@@ skipping 19 matching lines @@
       return const GreaterEqualOperation();
     } else if (operation == const GreaterOperation()) {
       return const LessOperation();
     } else if (operation == const GreaterEqualOperation()) {
       return const LessEqualOperation();
     } else {
       return null;
     }
   }
 
-  Range computeConstrainedRange(BinaryOperation operation,
-                                Range leftRange,
-                                Range rightRange) {
+  Range computeConstrainedRange(
+      BinaryOperation operation, Range leftRange, Range rightRange) {
     Range range;
     if (operation == const LessOperation()) {
       range = info.newNormalizedRange(
           const MinIntValue(), rightRange.upper - info.intOne);
     } else if (operation == const LessEqualOperation()) {
       range = info.newNormalizedRange(const MinIntValue(), rightRange.upper);
     } else if (operation == const GreaterOperation()) {
       range = info.newNormalizedRange(
           rightRange.lower + info.intOne, const MaxIntValue());
     } else if (operation == const GreaterEqualOperation()) {
       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();
+    if (condition is! HRelational) return info.newUnboundRange();
     if (condition is HIdentity) return info.newUnboundRange();
     HInstruction right = condition.right;
     HInstruction left = condition.left;
     if (!left.isInteger(compiler)) return info.newUnboundRange();
     if (!right.isInteger(compiler)) return info.newUnboundRange();
 
     Range rightRange = ranges[right];
     Range leftRange = ranges[left];
     Operation operation = condition.operation(constantSystem);
     Operation mirrorOp = flipOperation(operation);
@@ skipping 116 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);
   }
 }