RFC: Start refactoring to provide 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;
   Function run;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
   WorkItem.toCompile(this.element) : resolutionTree = null {
     run = (Compiler compiler) => compiler.compile(this);
   }
 
   WorkItem.toCodegen(this.element, this.resolutionTree) {
     run = (Compiler compiler) => compiler.codegen(this);
   }
 
   bool isAnalyzed() => resolutionTree != null;
 
   int hashCode() => element.hashCode();
 }
 
+interface Backend {
+  String codegen(WorkItem work);
+  void assembleProgram();
+}
+
+class JavaScriptBackend implements Backend {

[ahe, 2012/05/14 08:14:30]

Consider creating a separate library for this class.

[Anton Muhin, 2012/05/14 14:36:45]

What would be your recommendation where to place it?  into
compiler/implementation or compiler/implementation/ssa?

And is it worth creating a separate lib?  Maybe just a separate file?

+  Compiler compiler;
+  SsaBuilderTask builder;
+  SsaOptimizerTask optimizer;
+  SsaCodeGeneratorTask generator;
+  CodeEmitterTask emitter;
+
+  JavaScriptBackend(Compiler compiler)
+      : this.compiler = compiler,
+        builder = new SsaBuilderTask(compiler),
+        optimizer = new SsaOptimizerTask(compiler),
+        generator = new SsaCodeGeneratorTask(compiler),
+        emitter = new CodeEmitterTask(compiler);
+
+  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 assembleProgram() => emitter.assembleProgram();
+}
+
 class Compiler implements DiagnosticListener {
   Queue<WorkItem> worklist;
   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 workListIsClosed = false;
 
   Stopwatch codegenProgress;
 
   Compiler([this.tracer = const Tracer()])
       : universe = new Universe(),
         world = new World(),
         worklist = 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 173 matching lines @@
     world.populate(this, libraries);
     enqueue(new WorkItem.toCompile(main));
     codegenProgress.reset();
     while (!worklist.isEmpty()) {
       WorkItem work = worklist.removeLast();
       withCurrentElement(work.element, () => (work.run)(this));
     }
     workListIsClosed = true;
     assert(enqueuer.checkNoEnqueuedInvokedInstanceMethods());
     enqueuer.registerFieldClosureInvocations();
-    emitter.assembleProgram();
+    backend.assembleProgram();
     if (!worklist.isEmpty()) {
       internalErrorOnElement(worklist.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;
     }
   }
 
   String compile(WorkItem work) {
     String code = universe.generatedCode[work.element];
     if (code !== null) return code;
     analyze(work);
     return codegen(work);
   }
 
@@ skipping 193 matching lines @@
   }
 }
 
 class SourceSpan {
   final Uri uri;
   final int begin;
   final int end;
 
   const SourceSpan(this.uri, this.begin, this.end);
 }