Access ConstantSystem through ClosedWorld.

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 '../compiler.dart' show Compiler;
 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;
 import 'nodes.dart';
 import 'optimize.dart';
 
 class ValueRangeInfo {
   final ConstantSystem constantSystem;
 
   IntValue intZero;
   IntValue intOne;
 
@@ skipping 574 matching lines @@
    * save them here in order to remove them once the phase is done.
    */
   final List<HRangeConversion> conversions = <HRangeConversion>[];
 
   /**
    * Value ranges for integer instructions. This map gets populated by
    * the dominator tree visit.
    */
   final Map<HInstruction, Range> ranges = new Map<HInstruction, Range>();
 
-  final Compiler compiler;
+  final BackendHelpers backendHelpers;
   final ClosedWorld closedWorld;
-  final ConstantSystem constantSystem;
   final ValueRangeInfo info;
   final SsaOptimizerTask optimizer;
 
   HGraph graph;
 
   SsaValueRangeAnalyzer(
-      this.compiler, this.closedWorld, constantSystem, this.optimizer)
-      : info = new ValueRangeInfo(constantSystem),
-        this.constantSystem = constantSystem;
+      this.backendHelpers, ClosedWorld closedWorld, this.optimizer)
+      : info = new ValueRangeInfo(closedWorld.constantSystem),
+        this.closedWorld = closedWorld;
+
+  ConstantSystem get constantSystem => closedWorld.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;
@@ skipping 69 matching lines @@
     if (constantNum.isMinusZero) constantNum = new IntConstantValue(0);
     Value value = info.newIntValue(constantNum.primitiveValue);
     return info.newNormalizedRange(value, value);
   }
 
   Range visitFieldGet(HFieldGet fieldGet) {
     if (!fieldGet.isInteger(closedWorld)) return info.newUnboundRange();
     if (!fieldGet.receiver.isIndexablePrimitive(closedWorld)) {
       return visitInstruction(fieldGet);
     }
-    JavaScriptBackend backend = compiler.backend;
-    assert(fieldGet.element == backend.helpers.jsIndexableLength);
+    assert(fieldGet.element == backendHelpers.jsIndexableLength);
     PositiveValue value = info.newPositiveValue(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.newNormalizedRange(info.intZero, value);
   }
 
   Range visitBoundsCheck(HBoundsCheck check) {
     // Save the next instruction, in case the check gets removed.
@@ skipping 66 matching lines @@
     if (!left.isInteger(closedWorld)) return info.newUnboundRange();
     if (!right.isInteger(closedWorld)) 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));
+          .rewrite(relational, graph.addConstantBool(true, closedWorld));
       relational.block.remove(relational);
     } else if (negateOperation(operation).apply(leftRange, rightRange)) {
       relational.block
-          .rewrite(relational, graph.addConstantBool(false, compiler));
+          .rewrite(relational, graph.addConstantBool(false, closedWorld));
       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, 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,
@@ skipping 264 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);
   }
 }