Make codegen and optimizations depend more directly on data objects.

pkg/compiler/lib/src/ssa/codegen_helpers.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 '../constants/values.dart';
 import '../elements/elements.dart';
 import '../js_backend/js_backend.dart';
+import '../js_backend/interceptor_data.dart';
+import '../options.dart';
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../world.dart' show ClosedWorld;
 import 'nodes.dart';
 
 /**
  * Replaces some instructions with specialized versions to make codegen easier.
  * Caches codegen information on nodes.
  */
 class SsaInstructionSelection extends HBaseVisitor {
-  final Compiler compiler;
-  final ClosedWorld closedWorld;
+  final ClosedWorld _closedWorld;
+  final InterceptorData _interceptorData;
   HGraph graph;
 
-  SsaInstructionSelection(this.compiler, this.closedWorld);
-
-  JavaScriptBackend get backend => compiler.backend;
+  SsaInstructionSelection(this._closedWorld, this._interceptorData);
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
     visitDominatorTree(graph);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
@@ skipping 25 matching lines @@
   }
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitIs(HIs node) {
     if (node.kind == HIs.RAW_CHECK) {
       HInstruction interceptor = node.interceptor;
       if (interceptor != null) {
-        return new HIsViaInterceptor(
-            node.typeExpression, interceptor, closedWorld.commonMasks.boolType);
+        return new HIsViaInterceptor(node.typeExpression, interceptor,
+            _closedWorld.commonMasks.boolType);
       }
     }
     return node;
   }
 
   HInstruction visitIdentity(HIdentity node) {
     node.singleComparisonOp = simpleOp(node.left, node.right);
     return node;
   }
 
   String simpleOp(HInstruction left, HInstruction right) {
     // Returns the single identity comparison (== or ===) or null if a more
     // complex expression is required.
     TypeMask leftType = left.instructionType;
     TypeMask rightType = right.instructionType;
     if (leftType.isNullable && rightType.isNullable) {
       if (left.isConstantNull() ||
           right.isConstantNull() ||
-          (left.isPrimitive(closedWorld) && leftType == rightType)) {
+          (left.isPrimitive(_closedWorld) && leftType == rightType)) {
         return '==';
       }
       return null;
     }
     return '===';
   }
 
   HInstruction visitInvokeDynamic(HInvokeDynamic node) {
     if (node.isInterceptedCall) {
       tryReplaceInterceptorWithDummy(node, node.selector, node.mask);
     }
     return node;
   }
 
   HInstruction visitInvokeSuper(HInvokeSuper node) {
     if (node.isInterceptedCall) {
-      TypeMask mask = node.getDartReceiver(closedWorld).instructionType;
+      TypeMask mask = node.getDartReceiver(_closedWorld).instructionType;
       tryReplaceInterceptorWithDummy(node, node.selector, mask);
     }
     return node;
   }
 
   void tryReplaceInterceptorWithDummy(
       HInvoke node, Selector selector, TypeMask mask) {
     // Calls of the form
     //
     //     a.foo$1(a, x)
@@ skipping 16 matching lines @@
 
     // TODO(15933): Make automatically generated property extraction closures
     // work with the dummy receiver optimization.
     if (selector.isGetter) return;
 
     // This assignment of inputs is uniform for HInvokeDynamic and HInvokeSuper.
     HInstruction interceptor = node.inputs[0];
     HInstruction receiverArgument = node.inputs[1];
 
     if (interceptor.nonCheck() == receiverArgument.nonCheck()) {
-      if (backend.interceptorData.isInterceptedSelector(selector) &&
-          !backend.interceptorData.isInterceptedMixinSelector(selector, mask)) {
+      if (_interceptorData.isInterceptedSelector(selector) &&
+          !_interceptorData.isInterceptedMixinSelector(selector, mask)) {
         ConstantValue constant = new SyntheticConstantValue(
             SyntheticConstantKind.DUMMY_INTERCEPTOR,
             receiverArgument.instructionType);
-        HConstant dummy = graph.addConstant(constant, closedWorld);
+        HConstant dummy = graph.addConstant(constant, _closedWorld);
         receiverArgument.usedBy.remove(node);
         node.inputs[1] = dummy;
         dummy.usedBy.add(node);
       }
     }
   }
 
   HInstruction visitFieldSet(HFieldSet setter) {
     // Pattern match
     //     t1 = x.f; t2 = t1 + 1; x.f = t2; use(t2)   -->  ++x.f
@@ skipping 76 matching lines @@
     }
 
     HInstruction simpleBinary(String assignOp) {
       HInvokeBinary binary = op;
       return simple(assignOp, binary.left, binary.right);
     }
 
     HInstruction bitop(String assignOp) {
       // HBitAnd, HBitOr etc. are more difficult because HBitAnd(a.x, y)
       // sometimes needs to be forced to unsigned: a.x = (a.x & y) >>> 0.
-      if (op.isUInt31(closedWorld)) return simpleBinary(assignOp);
+      if (op.isUInt31(_closedWorld)) return simpleBinary(assignOp);
       return noMatchingRead();
     }
 
     if (op is HAdd) return plusOrMinus('+', '++');
     if (op is HSubtract) return plusOrMinus('-', '--');
 
     if (op is HStringConcat) return simple('+', op.left, op.right);
 
     if (op is HMultiply) return simpleBinary('*');
     if (op is HDivide) return simpleBinary('/');
@@ skipping 33 matching lines @@
     instruction.block.rewrite(instruction, instruction.checkedInput);
     instruction.block.remove(instruction);
   }
 }
 
 /**
  * Remove [HTypeConversion] instructions from the graph in '--trust-primitives'
  * mode.
  */
 class SsaTrustedCheckRemover extends HBaseVisitor {
-  Compiler compiler;
-  SsaTrustedCheckRemover(this.compiler);
+  final CompilerOptions _options;
+
+  SsaTrustedCheckRemover(this._options);
 
   void visitGraph(HGraph graph) {
-    if (!compiler.options.trustPrimitives) return;
+    if (!_options.trustPrimitives) return;
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction.accept(this);
       instruction = next;
     }
@@ skipping 11 matching lines @@
  * Instead of emitting each SSA instruction with a temporary variable
  * mark instructions that can be emitted at their use-site.
  * For example, in:
  *   t0 = 4;
  *   t1 = 3;
  *   t2 = add(t0, t1);
  * t0 and t1 would be marked and the resulting code would then be:
  *   t2 = add(4, 3);
  */
 class SsaInstructionMerger extends HBaseVisitor {
-  final Compiler compiler;
+  final JavaScriptBackend _backend;
   /**
    * List of [HInstruction] that the instruction merger expects in
    * order when visiting the inputs of an instruction.
    */
   List<HInstruction> expectedInputs;
   /**
    * Set of pure [HInstruction] that the instruction merger expects to
    * find. The order of pure instructions do not matter, as they will
    * not be affected by side effects.
    */
   Set<HInstruction> pureInputs;
   Set<HInstruction> generateAtUseSite;
 
   void markAsGenerateAtUseSite(HInstruction instruction) {
     assert(!instruction.isJsStatement());
     generateAtUseSite.add(instruction);
   }
 
-  SsaInstructionMerger(this.generateAtUseSite, this.compiler);
-
-  JavaScriptBackend get backend => compiler.backend;
+  SsaInstructionMerger(this.generateAtUseSite, this._backend);
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void analyzeInputs(HInstruction user, int start) {
     List<HInstruction> inputs = user.inputs;
     for (int i = start; i < inputs.length; i++) {
       HInstruction input = inputs[i];
       if (!generateAtUseSite.contains(input) &&
@@ skipping 62 matching lines @@
     // If aliased super members cannot be used, we will generate code like
     //
     //     C.prototype.method.call(instance)
     //
     // where instance is the [this] object for the method. In such a case, the
     // get of prototype might be evaluated before instance is created if we
     // generate instance at use site, which in turn might update the prototype
     // after first access if we use lazy initialization.
     // In this case, we therefore don't allow the receiver (the first argument)
     // to be generated at use site, and only analyze all other arguments.
-    if (!backend.canUseAliasedSuperMember(superMethod, selector)) {
+    if (!_backend.canUseAliasedSuperMember(superMethod, selector)) {
       analyzeInputs(instruction, 1);
     } else {
       super.visitInvokeSuper(instruction);
     }
   }
 
   void visitIs(HIs instruction) {
     // In the general case the input might be used multple multiple times, so it
     // must not be set generate at use site.
 
@@ skipping 350 matching lines @@
     }
 
     // If [thenInput] is defined in the first predecessor, then it is only used
     // by [phi] and can be generated at use site.
     if (identical(thenInput.block, end.predecessors[0])) {
       assert(thenInput.usedBy.length == 1);
       markAsGenerateAtUseSite(thenInput);
     }
   }
 }