Generative constructors in the new dart backend.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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.
 
 library tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 101 matching lines @@
           compiler.currentElement,
           "Reference to ${reference.definition} has no register");
     }
     ++variable.readCount;
     return variable;
   }
 
   ExecutableDefinition build(cps_ir.ExecutableDefinition node) {
     if (node is cps_ir.FieldDefinition) {
       return buildField(node);
+    } else if (node is cps_ir.ConstructorDefinition) {
+      return buildConstructor(node);
     } else if (node is cps_ir.FunctionDefinition) {
       return buildFunction(node);
     }
     assert(false);
+    return null;
   }
 
   FieldDefinition buildField(cps_ir.FieldDefinition node) {
     Statement body;
     if (node.hasInitializer) {
       currentElement = node.element;
-      returnContinuation = node.returnContinuation;
+      returnContinuation = node.body.returnContinuation;
 
       phiTempVar = new Variable(node.element, null);
 
       body = visit(node.body);
     }
     return new FieldDefinition(node.element, body);
   }
 
   Variable getFunctionParameter(cps_ir.Definition variable) {
     if (variable is cps_ir.Parameter) {
       return getVariable(variable);
     } else {
       return getClosureVariable(variable as cps_ir.ClosureVariable);
     }
   }
 
   FunctionDefinition buildFunction(cps_ir.FunctionDefinition node) {
     currentElement = node.element;
     List<Variable> parameters = <Variable>[];
     for (cps_ir.Definition p in node.parameters) {
       Variable parameter = getFunctionParameter(p);
       assert(parameter != null);
       ++parameter.writeCount; // Being a parameter counts as a write.
       parameters.add(parameter);
     }
-    returnContinuation = node.returnContinuation;
 
     Statement body;
     if (!node.isAbstract) {
+      returnContinuation = node.body.returnContinuation;
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
     }
 
     return new FunctionDefinition(node.element, parameters,
         body, node.localConstants, node.defaultParameterValues);
   }
 
+  ConstructorDefinition buildConstructor(cps_ir.ConstructorDefinition node) {
+    currentElement = node.element;
+    List<Variable> parameters = <Variable>[];
+    for (cps_ir.Definition p in node.parameters) {
+      Variable parameter = getFunctionParameter(p);
+      assert(parameter != null);
+      ++parameter.writeCount; // Being a parameter counts as a write.
+      parameters.add(parameter);
+    }
+    List<Initializer> initializers;
+    Statement body;
+    if (!node.isAbstract) {
+      initializers = node.initializers.map(visit).toList();
+      returnContinuation = node.body.returnContinuation;
+
+      phiTempVar = new Variable(node.element, null);
+      body = visit(node.body);
+    }
+
+    return new ConstructorDefinition(node.element, parameters,
+        body, initializers, node.localConstants, node.defaultParameterValues,
+        node.isConst);
+  }
+
+
   List<Expression> translateArguments(List<cps_ir.Reference> args) {
     return new List<Expression>.generate(args.length,
          (int index) => getVariableReference(args[index]));
   }
 
   List<Variable> translatePhiArguments(List<cps_ir.Reference> args) {
     return new List<Variable>.generate(args.length,
          (int index) => getVariableReference(args[index]));
   }
 
@@ skipping 91 matching lines @@
     if (first == null) {
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
   }
 
   visitNode(cps_ir.Node node) => throw "Unhandled node: $node";
 
+  Initializer visitFieldInitializer(cps_ir.FieldInitializer node) {
+    returnContinuation = node.body.returnContinuation;
+    return new FieldInitializer(node.element, visit(node.body.body));
+  }
+
+  Initializer visitSuperInitializer(cps_ir.SuperInitializer node) {
+    List<Statement> arguments =
+        node.arguments.map((cps_ir.RunnableBody argument) {
+      returnContinuation = argument.returnContinuation;
+      return visit(argument.body);
+    }).toList();
+    return new SuperInitializer(node.target, node.selector, arguments);
+  }
+
   Statement visitLetPrim(cps_ir.LetPrim node) {
     Variable variable = getVariable(node.primitive);
 
     // Don't translate unused primitives.
     if (variable == null) return visit(node.body);
 
     Node definition = visit(node.primitive);
 
     // visitPrimitive returns a Statement without successor if it cannot occur
     // in expression context (currently only the case for FunctionDeclarations).
     if (definition is Statement) {
       definition.next = visit(node.body);
       return definition;
     } else {
       return new Assign(variable, definition, visit(node.body));
     }
   }
 
+  Statement visitRunnableBody(cps_ir.RunnableBody node) {
+    return visit(node.body);
+  }
+
   Statement visitLetCont(cps_ir.LetCont node) {
     Label label;
     if (node.continuation.hasMultipleUses) {
       label = new Label();
       labels[node.continuation] = label;
     }
     Statement body = visit(node.body);
     // The continuation's body is not always translated directly here because
     // it may have been already translated:
     //   * For singly-used continuations, the continuation's body is
@@ skipping 199 matching lines @@
 
   Expression visitIdentical(cps_ir.Identical node) {
     return new InvokeStatic(
         compiler.identicalFunction,
         identicalSelector,
         <Expression>[getVariableReference(node.left),
                      getVariableReference(node.right)]);
   }
 }