Generative constructors in the new dart backend.

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

Index: pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart
diff --git a/pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart b/pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart
index 047a95078d5d74762d4d5bf4fa4956bc116521f5..f705ee3e5838b44949484e6845e11d567effba90 100644
--- a/pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart
+++ b/pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart
@@ -574,17 +574,35 @@ class IrBuilder {
     _current = null;
   }
 
+  ir.SuperInitializer makeSuperInitializer(ConstructorElement target,
+                                           Selector selector,
+                                           List<ir.RunnableBody> arguments) {
+    return new ir.SuperInitializer(target, arguments, selector);
+  }
+
+  ir.FieldInitializer makeFieldInitializer(FieldElement element,
+                                           ir.RunnableBody body) {
+    return new ir.FieldInitializer(element, body);
+  }
+
   /// Create a [ir.FieldDefinition] for the current [Element] using [_root] as
   /// the body using [initializer] as the initial value.
   ir.FieldDefinition makeFieldDefinition(ir.Primitive initializer) {
     if (initializer == null) {
       return new ir.FieldDefinition.withoutInitializer(state.currentElement);
     } else {
-      buildReturn(initializer);
       return new ir.FieldDefinition(state.currentElement,
-                                    state.returnContinuation,
-                                    _root);
+          makeRunnableBody(initializer));
+    }
+  }
+
+  ir.RunnableBody makeRunnableBody([ir.Primitive value]) {
+    if (value == null) {
+      _ensureReturn();
+    } else {
+      buildReturn(value);
     }
+    return new ir.RunnableBody(_root, state.returnContinuation);
   }
 
   /// Create a [ir.FunctionDefinition] for [element] using [_root] as the body.
@@ -603,13 +621,30 @@ class IrBuilder {
       return new ir.FunctionDefinition.abstract(
                 element, state.functionParameters, defaults);
     } else {
-      _ensureReturn();
       return new ir.FunctionDefinition(
-          element, state.returnContinuation, state.functionParameters, _root,
+          element, state.functionParameters, makeRunnableBody(),
           state.localConstants, defaults, closure.getClosureList(element));
     }
   }
 
+  ir.ConstructorDefinition makeConstructorDefinition(
+      List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
+    FunctionElement element = state.currentElement;
+    if (element.isExternal) {
+      assert(invariant(element, _root == null,
+          message: "Non-empty body for external constructor $element: $_root"));
+      assert(invariant(element, state.localConstants.isEmpty,
+          message: "Local constants for external constructor $element: "
+                   "${state.localConstants}"));
+      return new ir.ConstructorDefinition.abstract(
+                element, state.functionParameters, defaults, element.isConst);
+    }
+    return new ir.ConstructorDefinition(
+        element, state.functionParameters, makeRunnableBody(), initializers,

[floitsch, 2014/12/08 17:45:02]

assign "makeRunnableBody" to a temporary first, so that we have a name for it.

[sigurdm, 2014/12/09 09:57:10]

Done.

+        state.localConstants, defaults, element.isConst,
+        closure.getClosureList(element));
+  }
+
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].