RFC: Start refactoring to provide more than a single backend.

lib/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2011, 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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 315 matching lines @@
     List<HInstruction> users = instruction.usedBy;
     int length = users.length;
     for (int i = 0; i < length; i++) {
       if (users[i] is! HBoolify) return false;
     }
     return true;
   }
 
   HInstruction visitRelational(HRelational node) {
     if (allUsersAreBoolifies(node)) {
-      Interceptors interceptors = compiler.builder.interceptors;
+      Interceptors interceptors = compiler.backend.builder.interceptors;
       HStatic oldTarget = node.target;
       Element boolifiedInterceptor =
           interceptors.getBoolifiedVersionOf(oldTarget.element);
       if (boolifiedInterceptor !== null) {
         HStatic boolifiedTarget = new HStatic(boolifiedInterceptor);
         // We don't remove the [oldTarget] in case it is used by other
         // instructions. If it is unused it will be treated as dead code and
         // discarded.
         oldTarget.block.addAfter(oldTarget, boolifiedTarget);
         // Remove us as user from the [oldTarget].
@@ skipping 49 matching lines @@
   HInstruction visitIdentity(HIdentity node) {
     HInstruction newInstruction = handleIdentityCheck(node);
     return newInstruction === null ? super.visitIdentity(node) : newInstruction;
   }
 
   HInstruction foldBuiltinEqualsCheck(HEquals node) {
     // TODO(floitsch): cache interceptors.
     HInstruction newInstruction = handleIdentityCheck(node);
     if (newInstruction === null) {
       HStatic target = new HStatic(
-          compiler.builder.interceptors.getTripleEqualsInterceptor());
+          compiler.backend.builder.interceptors.getTripleEqualsInterceptor());
       node.block.addBefore(node, target);
       return new HIdentity(target, node.left, node.right);
     } else {
       return newInstruction;
     }
   }
 
   HInstruction visitEquals(HEquals node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
@@ skipping 21 matching lines @@
         // not implement operator=.
         return foldBuiltinEqualsCheck(node);
       }
     }
 
     if (right.isConstantNull()) {
       if (left.propagatedType.isPrimitive()) {
         return graph.addConstantBool(false);
       } else {
         // TODO(floitsch): cache interceptors.
-        Interceptors interceptors = compiler.builder.interceptors;
+        Interceptors interceptors = compiler.backend.builder.interceptors;
         Element equalsElement = interceptors.getEqualsInterceptor();
         // If we have a different element than [equalsElement], we
         // don't need to optimize this instruction to use another
         // element: we know the element is either eqNull or eqNullB.
         if (node.element === equalsElement) {
           Element targetElement = interceptors.getEqualsNullInterceptor();
           bool onlyUsedInBoolify = allUsersAreBoolifies(node);
           if (onlyUsedInBoolify) {
             targetElement = interceptors.getBoolifiedVersionOf(targetElement);
           }
@@ skipping 121 matching lines @@
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final String name = "SsaCheckInserter";
   Element lengthInterceptor;
 
   SsaCheckInserter(Compiler compiler) {
     SourceString lengthString = const SourceString('length');
     lengthInterceptor =
-        compiler.builder.interceptors.getStaticGetInterceptor(lengthString);
+        compiler.backend.builder.interceptors.getStaticGetInterceptor(lengthString);
   }
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction !== null) {
       HInstruction next = instruction.next;
@@ skipping 511 matching lines @@
         // the if block terminates. So any use of the instruction
         // after the join block should be changed to the new
         // instruction.
         changeUsesDominatedBy(ifUser.joinBlock, input, convertedType);
       }
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }