Start compiler refactoring to support more than a single backend.

lib/compiler/implementation/compiler.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 WorkItem {
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
@@ skipping 11 matching lines @@
       return compiler.codegen(this);
     } catch (CompilerCancelledException ex) {
       throw;
     } catch (var ex) {
       compiler.unhandledExceptionOnElement(element);
       throw;
     }
   }
 }
 
+class Backend {
+  final Compiler compiler;
+
+  Backend(this.compiler);
+
+  abstract String codegen(WorkItem work);
+  abstract void processNativeClasses(libraries);
+  abstract void assembleProgram();
+}
+
+class JavaScriptBackend extends Backend {
+  SsaBuilderTask builder;
+  SsaOptimizerTask optimizer;
+  SsaCodeGeneratorTask generator;
+  CodeEmitterTask emitter;
+
+  JavaScriptBackend(Compiler compiler)
+      : emitter = new CodeEmitterTask(compiler),
+        super(compiler) {
+    builder = new SsaBuilderTask(this);
+    optimizer = new SsaOptimizerTask(this);
+    generator = new SsaCodeGeneratorTask(this);
+  }
+
+  String codegen(WorkItem work) {
+    HGraph graph = builder.build(work);
+    optimizer.optimize(work, graph);
+    if (work.allowSpeculativeOptimization
+        && optimizer.trySpeculativeOptimizations(work, graph)) {
+      String code = generator.generateBailoutMethod(work, graph);
+      compiler.universe.addBailoutCode(work, code);
+      optimizer.prepareForSpeculativeOptimizations(work, graph);
+      optimizer.optimize(work, graph);
+    }
+    return generator.generateMethod(work, graph);
+  }
+
+  void processNativeClasses(libraries) {
+    native.processNativeClasses(emitter, libraries);
+  }
+
+  void assembleProgram() => emitter.assembleProgram();
+}
+
 class Compiler implements DiagnosticListener {
   Queue<WorkItem> codegenQueue;
   Universe universe;
   World world;
   String assembledCode;
   Namer namer;
   Types types;
   bool enableTypeAssertions = false;
 
   final Tracer tracer;
@@ skipping 30 matching lines @@
     }
   }
 
   List<CompilerTask> tasks;
   ScannerTask scanner;
   DietParserTask dietParser;
   ParserTask parser;
   TreeValidatorTask validator;
   ResolverTask resolver;
   TypeCheckerTask checker;
-  SsaBuilderTask builder;
-  SsaOptimizerTask optimizer;
-  SsaCodeGeneratorTask generator;
-  CodeEmitterTask emitter;
+  Backend backend;
   ConstantHandler constantHandler;
   EnqueueTask enqueuer;
 
   static final SourceString MAIN = const SourceString('main');
   static final SourceString NO_SUCH_METHOD = const SourceString('noSuchMethod');
   static final SourceString NO_SUCH_METHOD_EXCEPTION =
       const SourceString('NoSuchMethodException');
   static final SourceString START_ROOT_ISOLATE =
       const SourceString('startRootIsolate');
   bool enabledNoSuchMethod = false;
 
   bool codegenQueueIsClosed = false;
 
   Stopwatch codegenProgress;
 
   Compiler([this.tracer = const Tracer()])
       : universe = new Universe(),
         world = new World(),
         codegenQueue = new Queue<WorkItem>(),
         codegenProgress = new Stopwatch.start() {
     namer = new Namer(this);
     constantHandler = new ConstantHandler(this);
     scanner = new ScannerTask(this);
     dietParser = new DietParserTask(this);
     parser = new ParserTask(this);
     validator = new TreeValidatorTask(this);
     resolver = new ResolverTask(this);
     checker = new TypeCheckerTask(this);
-    builder = new SsaBuilderTask(this);
-    optimizer = new SsaOptimizerTask(this);
-    generator = new SsaCodeGeneratorTask(this);
-    emitter = new CodeEmitterTask(this);
+    backend = new JavaScriptBackend(this);
     enqueuer = new EnqueueTask(this);
     tasks = [scanner, dietParser, parser, resolver, checker,
-             builder, optimizer, generator,
-             emitter, constantHandler, enqueuer];
+             constantHandler, enqueuer];
   }
 
   void ensure(bool condition) {
     if (!condition) cancel('failed assertion in leg');
   }
 
   void unimplemented(String methodName,
                      [Node node, Token token, HInstruction instruction,
                       Element element]) {
     internalError("$methodName not implemented",
@@ skipping 166 matching lines @@
       reportFatalError('Could not find $MAIN', mainApp);
     } else {
       if (!main.isFunction()) reportFatalError('main is not a function', main);
       FunctionElement mainMethod = main;
       FunctionSignature parameters = mainMethod.computeSignature(this);
       parameters.forEachParameter((Element parameter) {
         reportFatalError('main cannot have parameters', parameter);
       });
     }
     Collection<LibraryElement> libraries = universe.libraries.getValues();
-    native.processNativeClasses(this, libraries);
+    backend.processNativeClasses(libraries);
     world.populate(this, libraries);
     addToWorkList(main);
     codegenProgress.reset();
     while (!codegenQueue.isEmpty()) {
       WorkItem work = codegenQueue.removeLast();
       withCurrentElement(work.element, () => work.run(this));
     }
     codegenQueueIsClosed = true;
     assert(enqueuer.checkNoEnqueuedInvokedInstanceMethods());
     enqueuer.registerFieldClosureInvocations();
-    emitter.assembleProgram();
+    backend.assembleProgram();
     if (!codegenQueue.isEmpty()) {
       internalErrorOnElement(codegenQueue.first().element,
                              "work list is not empty");
     }
   }
 
   TreeElements analyzeElement(Element element) {
     assert(parser !== null);
     Node tree = parser.parse(element);
     validator.validate(tree);
@@ skipping 11 matching lines @@
     if (codegenProgress.elapsedInMs() > 500) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       log('compiled ${universe.generatedCode.length} methods');
       codegenProgress.reset();
     }
     if (work.element.kind.category == ElementCategory.VARIABLE) {
       constantHandler.compileWorkItem(work);
       return null;
     } else {
-      HGraph graph = builder.build(work);
-      optimizer.optimize(work, graph);
-      if (work.allowSpeculativeOptimization
-          && optimizer.trySpeculativeOptimizations(work, graph)) {
-        String code = generator.generateBailoutMethod(work, graph);
-        universe.addBailoutCode(work, code);
-        optimizer.prepareForSpeculativeOptimizations(work, graph);
-        optimizer.optimize(work, graph);
-        code = generator.generateMethod(work, graph);
-        universe.addGeneratedCode(work, code);
-        return code;
-      } else {
-        String code = generator.generateMethod(work, graph);
-        universe.addGeneratedCode(work, code);
-        return code;
-      }
+      String code = backend.codegen(work);
+      universe.addGeneratedCode(work, code);
+      return code;
     }
   }
 
   void addToWorkList(Element element, [TreeElements elements]) {
     if (codegenQueueIsClosed) {
       internalErrorOnElement(element, "work list is closed");
     }
     if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
       registerInstantiatedClass(element.enclosingElement);
     }
@@ skipping 186 matching lines @@
   }
 }
 
 class SourceSpan {
   final Uri uri;
   final int begin;
   final int end;
 
   const SourceSpan(this.uri, this.begin, this.end);
 }