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

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 15 matching lines @@
       <Element, ir.FunctionDefinition>{};
 
   IrBuilderTask(Compiler compiler) : super(compiler);
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
   ir.FunctionDefinition getIr(Element element) => nodes[element.implementation];
 
-  void buildNodes({bool useNewBackend: false}) {
-    if (!irEnabled(useNewBackend: useNewBackend)) return;
+  ir.FunctionDefinition buildNode(AstElement element) {
+    if (!canBuild(element)) return null;
+    TreeElements elementsMapping = element.resolvedAst.elements;
+    element = element.implementation;
+    return compiler.withCurrentElement(element, () {
+      SourceFile sourceFile = elementSourceFile(element);
+      IrBuilderVisitor builder =
+          new IrBuilderVisitor(elementsMapping, compiler, sourceFile);
+      ir.FunctionDefinition function;
+      function = builder.buildFunction(element);
+
+      return function;
+    });
+  }
+
+  void buildNodes() {
+    if (!irEnabled()) return;

[floitsch, 2014/11/13 14:30:55]

We should not call `buildNodes` if we aren't interested in its results.

[sigurdm, 2014/11/13 14:43:41]

Done.

     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
       resolved.forEach((AstElement element) {
-        if (canBuild(element)) {
-          TreeElements elementsMapping = element.resolvedAst.elements;
-          element = element.implementation;
-          compiler.withCurrentElement(element, () {
-            SourceFile sourceFile = elementSourceFile(element);
-            IrBuilderVisitor builder =
-                new IrBuilderVisitor(elementsMapping, compiler, sourceFile);
-            ir.FunctionDefinition function;
-            function = builder.buildFunction(element);
-
-            if (function != null) {
-              nodes[element] = function;
-              compiler.tracer.traceCompilation(element.name, null);
-              compiler.tracer.traceGraph("IR Builder", function);
-            }
-          });
+        ir.FunctionDefinition functionDefinition = buildNode(element);
+        if (functionDefinition != null) {
+          nodes[element] = functionDefinition;
         }
       });
     });
   }
 
-  bool irEnabled({bool useNewBackend: false}) {
+  bool irEnabled() {
     // TODO(sigurdm,kmillikin): Support checked-mode checks.
-    return (useNewBackend || const bool.fromEnvironment('USE_NEW_BACKEND')) &&
-        compiler.backend is DartBackend &&
-        !compiler.enableTypeAssertions &&
-        !compiler.enableConcreteTypeInference;
+    return compiler.backend is DartBackend &&
+           !compiler.enableTypeAssertions &&

[floitsch, 2014/11/13 14:30:55]

These checks should probably go to the compiler too.

[sigurdm, 2014/11/13 14:43:41]

TODO added

+           !compiler.enableConcreteTypeInference;
   }
 
   bool canBuild(Element element) {
     FunctionElement function = element.asFunctionElement();
     // TODO(kmillikin,sigurdm): support lazy field initializers.
     if (function == null) return false;
 
     if (!compiler.backend.shouldOutput(function)) return false;
 
     assert(invariant(element, !function.isNative));
@@ skipping 807 matching lines @@
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 }