Start compiler refactoring to support more than a single backend.

lib/compiler/implementation/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 120 matching lines @@
   }
 
   Element getGetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('getRuntimeTypeInfo'));
   }
 }
 
 class SsaBuilderTask extends CompilerTask {
   final Interceptors interceptors;
   final Map<Node, ClosureData> closureDataCache;
+  final CodeEmitterTask emitter;
 
   String get name() => 'SSA builder';
 
-  SsaBuilderTask(Compiler compiler)
-    : interceptors = new Interceptors(compiler),
+  SsaBuilderTask(JavaScriptBackend backend)
+    : interceptors = new Interceptors(backend.compiler),
       closureDataCache = new HashMap<Node, ClosureData>(),
-      super(compiler);
+      emitter = backend.emitter,
+      super(backend.compiler);
 
   HGraph build(WorkItem work) {
     return measure(() {
       FunctionElement element = work.element;
       HInstruction.idCounter = 0;
-      SsaBuilder builder = new SsaBuilder(compiler, work);
+      SsaBuilder builder = new SsaBuilder(this, work);
       HGraph graph;
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
           graph = compileConstructor(builder, work);
           break;
         case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
           graph = builder.buildMethod(work.element);
@@ skipping 128 matching lines @@
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
 
-    ClosureTranslator translator =
-        new ClosureTranslator(builder.compiler, builder.elements);
+    ClosureTranslator translator = new ClosureTranslator(builder);
     closureData = translator.translate(node);
 
     FunctionSignature params = function.computeSignature(builder.compiler);
     params.forEachParameter((Element element) {
       HInstruction parameter = new HParameterValue(element);
       builder.add(parameter);
       parameter = builder.potentiallyCheckType(parameter, element);
       directLocals[element] = parameter;
     });
 
@@ skipping 446 matching lines @@
     List<LabelElement> result = null;
     for (LabelElement element in target.labels) {
       if (result === null) result = <LabelElement>[];
       result.add(element);
     }
     return (result === null) ? const <LabelElement>[] : result;
   }
 }
 
 class SsaBuilder implements Visitor {
-  final Compiler compiler;
+  final SsaBuilderTask builder;
   TreeElements elements;
   final Interceptors interceptors;
   final WorkItem work;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
 
   Map<TargetElement, JumpHandler> jumpTargets;
 
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack;
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
   // The most recently opened block. Has the same value as [current] while
   // the block is open, but unlike [current], it isn't cleared when the current
   // block is closed.
   HBasicBlock lastOpenedBlock;
 
   LibraryElement get currentLibrary() => work.element.getLibrary();
+  Compiler get compiler() => builder.compiler;
+  CodeEmitterTask get emitter() => builder.emitter;
 
-  SsaBuilder(Compiler compiler, WorkItem work)
-    : this.compiler = compiler,
+  SsaBuilder(SsaBuilderTask builder, WorkItem work)
+    : this.builder = builder,
       this.work = work,
-      interceptors = compiler.builder.interceptors,
+      interceptors = builder.interceptors,
       methodInterceptionEnabled = true,
       elements = work.resolutionTree,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
       jumpTargets = new Map<TargetElement, JumpHandler>() {
     localsHandler = new LocalsHandler(this);
   }
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
@@ skipping 658 matching lines @@
             wrapExpressionGraph(conditionExpression),
             wrapStatementGraph(bodyGraph),
             null,
             loopEntryBlock.loopInformation.target,
             loopEntryBlock.loopInformation.labels);
     loopEntryBlock.setBlockFlow(loopBlockInfo, current);
     loopInfo.loopBlockInformation = loopBlockInfo;
   }
 
   visitFunctionExpression(FunctionExpression node) {
-    ClosureData nestedClosureData = compiler.builder.closureDataCache[node];
+    ClosureData nestedClosureData = builder.closureDataCache[node];
     if (nestedClosureData === null) {
       // TODO(floitsch): we can only assume that the reason for not having a
       // closure data here is, because the function is inside an initializer.
       compiler.unimplemented("Closures inside initializers", node: node);
     }
     assert(nestedClosureData !== null);
     assert(nestedClosureData.closureClassElement !== null);
     ClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
@@ skipping 1886 matching lines @@
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
   HInstruction result(Node node) {
     flushLiterals(node);
     return prefix;
   }
 }