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

pkg/compiler/lib/src/js_backend/codegen/task.dart

Index: pkg/compiler/lib/src/js_backend/codegen/task.dart
diff --git a/pkg/compiler/lib/src/js_backend/codegen/task.dart b/pkg/compiler/lib/src/js_backend/codegen/task.dart
new file mode 100644
index 0000000000000000000000000000000000000000..3b877a33349f82eeeb1ac306e531ddf0e77dd587
--- /dev/null
+++ b/pkg/compiler/lib/src/js_backend/codegen/task.dart
@@ -0,0 +1,149 @@
+// Copyright (c) 2014, 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.
+
+/// Generate code using the cps-based IR pipeline.
+library code_generator_task;
+
+import '../../dart2jslib.dart';
+import '../../source_file.dart';
+import '../../cps_ir/cps_ir_nodes.dart' as cps_ir;

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

I would go with "as cps".

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

Done.

+import '../../cps_ir/cps_ir_builder.dart';
+import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
+import '../../tree/tree.dart' as ast;
+import '../../scanner/scannerlib.dart' as scanner;
+import '../../elements/elements.dart';
+import '../../js/js.dart' as js;
+import '../../source_map_builder.dart';
+import '../../tree_ir/tree_ir_builder.dart' as tree_builder;
+import '../../dart_backend/backend_ast_emitter.dart' as backend_ast_emitter;
+import '../../cps_ir/optimizers.dart';
+import '../../tracer.dart';
+import '../../dart_backend/statement_rewriter.dart';
+import '../../dart_backend/copy_propagator.dart';
+import '../../dart_backend/loop_rewriter.dart';
+import '../../dart_backend/logical_rewriter.dart';
+import '../../js_backend/codegen/codegen.dart';
+
+class CodeGenTask extends CompilerTask {
+
+  Tracer tracer; // TODO(sigurdm): Assign this.

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

nit: two spaces before "//".

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

Done.

+
+  String get name => 'CPS Ir pipeline';
+
+  final IrBuilderTask irBuilderTask;
+
+  ConstantSystem get constantSystem => compiler.backend.constantSystem;
+
+  CodeGenTask(Compiler compiler)
+      : irBuilderTask = new IrBuilderTask(compiler),
+        super(compiler);
+
+  js.Fun build(CodegenWorkItem work) {

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

This is the public entry point.
Add dartdoc.

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

Done.

+    return measure(() {
+      AstElement element = work.element;
+
+      return compiler.withCurrentElement(element, () {
+        cps_ir.FunctionDefinition cps_definition;

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

cpsDefinition =
    irBuilderTask.buildNode(element);

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

cpsDefinition

Probably a copy/paste. Please fix the source too.

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

Seems to be my mistake only

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

Done.

+        cps_definition = irBuilderTask.buildNode(element);
+        if (cps_definition == null) return null;
+
+        // Transformations on the CPS IR.
+        if (tracer != null) {
+          tracer.traceCompilation(element.name, null);

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

The cps_ir_builder_visitor.dart already does a tracer.traceCompilation.
Are we duplicating the tracing?

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

It seems so - I disabled the tracing from cps_ir_builder_visitor.dart.

+        }
+
+        void traceGraph(String title, var irObject) {
+          if (tracer != null) {
+            tracer.traceGraph(title, irObject);
+          }
+        }
+
+        new ConstantPropagator(compiler, constantSystem)
+            .rewrite(cps_definition);
+        traceGraph("Sparse constant propagation", cps_definition);
+        new RedundantPhiEliminator().rewrite(cps_definition);
+        traceGraph("Redundant phi elimination", cps_definition);
+        new ShrinkingReducer().rewrite(cps_definition);
+        traceGraph("Shrinking reductions", cps_definition);
+
+        // Do not rewrite the IR after variable allocation.  Allocation
+        // makes decisions based on an approximation of IR variable live
+        // ranges that can be invalidated by transforming the IR.
+        new cps_ir.RegisterAllocator().visit(cps_definition);
+
+        tree_builder.Builder builder = new tree_builder.Builder(compiler);
+        tree_ir.FunctionDefinition definition = builder.build(cps_definition);
+        assert(definition != null);
+        traceGraph('Tree builder', definition);
+
+        // Transformations on the Tree IR.
+        new StatementRewriter().rewrite(definition);
+        traceGraph('Statement rewriter', definition);
+        new CopyPropagator().rewrite(definition);
+        traceGraph('Copy propagation', definition);
+        new LoopRewriter().rewrite(definition);
+        traceGraph('Loop rewriter', definition);
+        new LogicalRewriter().rewrite(definition);
+        traceGraph('Logical rewriter', definition);
+        new backend_ast_emitter.UnshadowParameters().unshadow(definition);
+        traceGraph('Unshadow parameters', definition);
+
+        CodeGen codeGen = new CodeGen();
+        try {
+          codeGen.buildFunction(definition);
+          return buildJavaScriptFunction(work.element,
+                                         codeGen.parameters,

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

I don't like to return values as fields.
Let's revisit that in a later CL.

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

Acknowledged.

+                                         codeGen.body);
+        } catch (e, tr) {
+          if (e == CodeGen.UNIMPLEMENTED) {
+            return null;
+          } else {
+            rethrow;
+          }
+        }
+
+      });
+    });
+  }
+
+  js.Node attachPosition(js.Node node, AstElement element) {
+    // TODO(sra): Attaching positions might be cleaner if the source position
+    // was on a wrapping node.
+    SourceFile sourceFile = sourceFileOfElement(element);
+    String name = element.name;
+    AstElement implementation = element.implementation;
+    ast.Node expression = implementation.node;
+    scanner.Token beginToken;
+    scanner.Token endToken;
+    if (expression == null) {
+      // Synthesized node. Use the enclosing element for the location.
+      beginToken = endToken = element.position;
+    } else {
+      beginToken = expression.getBeginToken();
+      endToken = expression.getEndToken();
+    }
+    // TODO(podivilov): find the right sourceFile here and remove offset
+    // checks below.
+    var sourcePosition, endSourcePosition;
+    if (beginToken.charOffset < sourceFile.length) {
+      sourcePosition =
+          new TokenSourceFileLocation(sourceFile, beginToken, name);
+    }
+    if (endToken.charOffset < sourceFile.length) {
+      endSourcePosition =
+          new TokenSourceFileLocation(sourceFile, endToken, name);
+    }
+    return node.withPosition(sourcePosition, endSourcePosition);
+  }
+
+  SourceFile sourceFileOfElement(Element element) {
+    return element.implementation.compilationUnit.script.file;
+  }
+
+  js.Fun buildJavaScriptFunction(FunctionElement element,
+                                 List<js.Parameter> parameters,
+                                 js.Block body) {
+    return attachPosition(new js.Fun(parameters, body), element);
+  }
+}