Handle named and optional arguments in cps-ir.

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

 // 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 'glue.dart';
 import 'codegen.dart';
 
@@ skipping 14 matching lines @@
 import '../../cps_ir/optimizers.dart';
 import '../../tracer.dart';
 import '../../js_backend/codegen/codegen.dart';
 import '../../ssa/ssa.dart' as ssa;
 import '../../tree_ir/optimization/optimization.dart';
 import '../../common.dart' show SelectorKind;
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
 
 class JsBackendTreeBuilder extends tree_builder.Builder {
-  JsBackendTreeBuilder(Compiler compiler) : super(compiler);
+  final Glue glue;
+
+  JsBackendTreeBuilder(Compiler compiler, this.glue) : super(compiler);
 
   Selector get identicalSelector {
     return new Selector(SelectorKind.CALL, 'identical', null, 2);
   }
 
   /// TOOD(karlklose): cache this?
   tree_ir.Constant get constantTrue {
     ConstantExpression trueValue =
         new PrimitiveConstantExpression(new TrueConstantValue());
     return new tree_ir.Constant(trueValue);
   }
 
   /**
    * Boolean conversion maps any object o into a boolean. Boolean conversion is
    * defined by the function application
    *   (bool v){
    *     assert(v != null);
    *     return identical(v, true);
    *   }(o)
    */
   tree_ir.Expression visitIsTrue(cps.IsTrue node) {
     tree_ir.Expression value = getVariableReference(node.value);
     /// TODO(karlklose): implement the assert(v != null) check.
     return new tree_ir.InvokeStatic(
-        compiler.identicalFunction,
+        glue.identicalFunction,
         identicalSelector,
         <tree_ir.Expression>[value, constantTrue]);
   }
 
 }
 
 class CspFunctionCompiler implements FunctionCompiler {
   final IrBuilderTask irBuilderTask;
   final ConstantSystem constantSystem;
   final Compiler compiler;
+  final Glue glue;
 
   // TODO(karlklose,sigurm): remove and update dart-doc of [compile].
   final FunctionCompiler fallbackCompiler;
 
   // TODO(sigurdm): Assign this.
   Tracer tracer;
 
   CspFunctionCompiler(Compiler compiler, JavaScriptBackend backend)
       : irBuilderTask = new IrBuilderTask(compiler),
         fallbackCompiler = new ssa.SsaFunctionCompiler(backend, true),
         constantSystem = backend.constantSystem,
-        compiler = compiler;
+        compiler = compiler,
+        glue = new Glue(compiler);
 
   String get name => 'CPS Ir pipeline';
 
   /// Generates JavaScript code for `work.element`. First tries to use the
   /// Cps Ir -> tree ir -> js pipeline, and if that fails due to language
   /// features not implemented it will fall back to the ssa pipeline (for
   /// platform code) or will cancel compilation (for user code).
   js.Fun compile(CodegenWorkItem work) {
     AstElement element = work.element;
     return compiler.withCurrentElement(element, () {
@@ skipping 57 matching lines @@
     traceGraph("Shrinking reductions", cpsNode);
 
     // 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.RegisterAllocator().visit(cpsNode);
     return cpsNode;
   }
 
   tree_ir.FunctionDefinition compileToTreeIR(cps.FunctionDefinition cpsNode) {
-    tree_builder.Builder builder = new JsBackendTreeBuilder(compiler);
+    tree_builder.Builder builder = new JsBackendTreeBuilder(compiler, glue);
     tree_ir.FunctionDefinition treeNode = builder.build(cpsNode);
     assert(treeNode != null);
     traceGraph('Tree builder', treeNode);
     return treeNode;
   }
 
   tree_ir.FunctionDefinition optimizeTreeIR(
       tree_ir.FunctionDefinition treeNode) {
     // Transformations on the Tree IR.
     new StatementRewriter().rewrite(treeNode);
     traceGraph('Statement rewriter', treeNode);
     new CopyPropagator().rewrite(treeNode);
     traceGraph('Copy propagation', treeNode);
     new LoopRewriter().rewrite(treeNode);
     traceGraph('Loop rewriter', treeNode);
     new LogicalRewriter().rewrite(treeNode);
     traceGraph('Logical rewriter', treeNode);
     new backend_ast_emitter.UnshadowParameters().unshadow(treeNode);
     traceGraph('Unshadow parameters', treeNode);
     return treeNode;
   }
 
   js.Fun compileToJavaScript(CodegenWorkItem work,
                              tree_ir.FunctionDefinition definition) {
     CodeGenerator codeGen =
-        new CodeGenerator(new Glue(compiler), work.registry);
+        new CodeGenerator(glue, work.registry);

[karlklose, 2014/11/21 10:03:20]

Does it fit on one line now?

[sigurdm, 2014/11/21 10:09:10]

Yes

 
     codeGen.buildFunction(definition);
     return buildJavaScriptFunction(work.element,
                                    codeGen.parameters,
                                    codeGen.body);
   }
 
   Iterable<CompilerTask> get tasks {
     // TODO(sigurdm): Make a better list of tasks.
     return <CompilerTask>[irBuilderTask]..addAll(fallbackCompiler.tasks);
@@ skipping 32 matching lines @@
   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);
   }
 }