Set up a stub pipline for using the new cps-based ir to generate js.

pkg/compiler/lib/src/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 79 matching lines @@
   LibraryElement internalLibrary;
 
 
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassElement> get classesRequiredForReflection {
     // TODO(herhut): Clean this up when classes needed for rti are tracked.
     return [closureClass, jsIndexableClass];
   }
 
-  SsaBuilderTask builder;
+  SsaBuilderTask ssaBuilder;
+  CodeGenTask cpsBuilder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
     return compiler.enqueuer.codegen.generatedCode;
   }
@@ skipping 212 matching lines @@
    */
   final Set<ClassElement> specialOperatorEqClasses = new Set<ClassElement>();
 
   /**
    * A set of members that are called from subclasses via super.
    */
   final Set<FunctionElement> aliasedSuperMembers =
       new Setlet<FunctionElement>();
 
   List<CompilerTask> get tasks {
-    return <CompilerTask>[builder, optimizer, generator, emitter];
+    return <CompilerTask>[ssaBuilder, optimizer, generator, emitter];
   }
 
   final RuntimeTypes rti;
 
   /// Holds the method "disableTreeShaking" in js_mirrors when
   /// dart:mirrors has been loaded.
   FunctionElement disableTreeShakingMarker;
 
   /// Holds the method "preserveNames" in js_mirrors when
   /// dart:mirrors has been loaded.
@@ skipping 94 matching lines @@
   JavaScriptResolutionCallbacks resolutionCallbacks;
 
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
         super(compiler) {
     emitter = new CodeEmitterTask(compiler, namer, generateSourceMap);
-    builder = new SsaBuilderTask(this);
+    ssaBuilder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
+    cpsBuilder = Compiler.USE_CPS_IR
+        ? new CodeGenTask(compiler)

[floitsch, 2014/11/12 11:03:20]

I prefer "Codegen", but I can see why the "G" should be capitalized.

[sigurdm, 2014/11/13 08:29:42]

It is renamed to CodeGenerator in the next CL.

+        : null;
     typeVariableHandler = new TypeVariableHandler(this);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
@@ skipping 735 matching lines @@
         // the checked setter.
         if (Elements.isStaticOrTopLevel(element)) return;
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         compiler.enqueuer.codegen.registerStaticUse(getCyclicThrowHelper());
       }
     }
-    HGraph graph = builder.build(work);
-    optimizer.optimize(work, graph);
-    jsAst.Expression code = generator.generateCode(work, graph);
+    jsAst.Expression code;

[floitsch, 2014/11/12 11:03:20]

Alternatively we could:
- have one "CodegenTask" in this class.
- Make that one either a SsaCodegenTask or a CpsCodegenTask.
- let the SsaCodegenTask do the optimizer.optimize + get generator.generateCode.
- let the CpsCodegenTask fall back to the SsaCodegen if it can't handle the
code. That is, it would always return valid code and the backend wouldn't need
to know that the CpsCodegen isn't complete yet. (The code here, would then live
in the CpsCodegenTask).

[sigurdm, 2014/11/13 08:29:41]

Done.

+    if (Compiler.USE_CPS_IR) {
+      if(!work.element.isGenerativeConstructorBody &&
+        work.element.enclosingClass is! ClosureClassElement) {
+        // First try to compile with the new backend.
+        // Will return null if it failed to compile.
+        code = cpsBuilder.build(work);
+      }
+    }
+    if (code == null) {
+      HGraph graph = ssaBuilder.build(work);
+      optimizer.optimize(work, graph);
+      code = generator.generateCode(work, graph);
+    }
     generatedCode[element] = code;
   }
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
     return new native.NativeCodegenEnqueuer(world, compiler, emitter);
   }
@@ skipping 1242 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }