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;
 
+const bool USE_CPS_IR = const bool.fromEnvironment("USE_CPS_IR");
+
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
   final Set<HInstruction> allocatedFixedLists = new Set<HInstruction>();
 }
 
+abstract class FunctionCompiler {
+  /// Generates JavaScript code for `work.element`.
+  jsAst.Fun compile(CodegenWorkItem work);
+
+  Iterable get tasks;
+}
+
 /*
  * Invariants:
  *   canInline(function) implies canInline(function, insideLoop:true)
  *   !canInline(function, insideLoop: true) implies !canInline(function)
  */
 class FunctionInlineCache {
   final Map<FunctionElement, bool> canBeInlined =
       new Map<FunctionElement, bool>();
 
   final Map<FunctionElement, bool> canBeInlinedInsideLoop =
@@ skipping 66 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;
-  SsaOptimizerTask optimizer;
-  SsaCodeGeneratorTask generator;
+  FunctionCompiler functionCompiler;
+
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
     return compiler.enqueuer.codegen.generatedCode;
   }
 
   FunctionInlineCache inlineCache = new FunctionInlineCache();
@@ skipping 210 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];
+    List<CompilerTask> result = functionCompiler.tasks;
+    result.add(emitter);
+    return result;
   }
 
   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);
-    optimizer = new SsaOptimizerTask(this);
-    generator = new SsaCodeGeneratorTask(this);
     typeVariableHandler = new TypeVariableHandler(this);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
+    functionCompiler = USE_CPS_IR
+         ? new CspFunctionCompiler(compiler, this)
+         : new SsaFunctionCompiler(this);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
@@ skipping 715 matching lines @@
 
   void codegen(CodegenWorkItem work) {
     Element element = work.element;
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) return;
     if (element.isConstructor && element.enclosingClass == jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
       return;
     }
     if (kind.category == ElementCategory.VARIABLE) {
-      ConstantExpression initialValue = constants.getConstantForVariable(element);
+      ConstantExpression initialValue =
+          constants.getConstantForVariable(element);
       if (initialValue != null) {
         registerCompileTimeConstant(initialValue.value, work.registry);
         constants.addCompileTimeConstantForEmission(initialValue.value);
         // We don't need to generate code for static or top-level
         // variables. For instance variables, we may need to generate
         // 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);
-    generatedCode[element] = code;
+    generatedCode[element] = functionCompiler.compile(work);
   }
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
     return new native.NativeCodegenEnqueuer(world, compiler, emitter);
   }
 
@@ skipping 1241 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);
 }