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>[];
@@ skipping 12 matching lines @@
 
   String compile(Compiler compiler) {
     return compiler.compile(this);
   }
 
   String codegen(Compiler compiler) {
     return compiler.codegen(this);
   }
 }
 
+interface Backend {

[ahe, 2012/05/11 11:39:48]

This looks reasonable, but I would prefer to have a common base class instead of
an interface. In dart2js, we tend to make much fewer interfaces than is common
in Java.

One of the reasons is that we have implicit interfaces from classes.

Also, there is a bit of an allergic reaction based on our experience in dartc.

[floitsch, 2012/05/11 13:51:04]

Personally I prefer an interface over an empty class. If there is something to
share, I would of course prefer a class.

[Anton Muhin, 2012/05/12 15:48:43]

I erred to interface for as of now I'd rather move any common code into compiler
than backend.

Again, you all should know this stuff better so I'd introduce a base class if
you think it's better approach.

On 2012/05/11 13:51:04, floitsch wrote:

+  String codegen(WorkItem work);
+}
+
+class JsBackend implements Backend {

[ahe, 2012/05/11 11:39:48]

Personally, I prefer JavaScriptBackend instead of the abbreviation.

[Anton Muhin, 2012/05/12 15:48:43]

Done.

+  Compiler compiler;
+  SsaBuilderTask builder;
+  SsaOptimizerTask optimizer;
+  SsaCodeGeneratorTask generator;
+
+  JsBackend(Compiler compiler)
+      : this.compiler = compiler,
+        builder = new SsaBuilderTask(compiler),
+        optimizer = new SsaOptimizerTask(compiler),
+        generator = new SsaCodeGeneratorTask(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);
+  }
+}
+
 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;
+  Backend backend;
   CodeEmitterTask emitter;
   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);
+    backend = new JsBackend(this);
     emitter = new CodeEmitterTask(this);
     enqueuer = new EnqueueTask(this);
     tasks = [scanner, dietParser, parser, resolver, checker,
-             builder, optimizer, generator,
              emitter, 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]) {
@@ skipping 206 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 198 matching lines @@
   }
 }
 
 class SourceSpan {
   final Uri uri;
   final int begin;
   final int end;
 
   const SourceSpan(this.uri, this.begin, this.end);
 }