Generative constructors in the new dart backend.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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.
 
 library dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 562 matching lines @@
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = buildNullLiteral();
     add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
   }
 
+  ir.SuperInitializer makeSuperInitializer(ConstructorElement target,

[Kevin Millikin (Google), 2014/12/11 09:28:25]

Is there any reason that this function takes the arguments in a different order
than the constructor?

If one order is better than the other, it seems like they should both use it.

[sigurdm, 2014/12/17 10:20:56]

No reason besides oversight.

+                                           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);
+      ir.RunnableBody body = makeRunnableBody();
+      return new ir.FieldDefinition(state.currentElement, body);
     }
   }
 
+  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.
   ///
   /// Parameters must be created before the construction of the body using
   /// [createFunctionParameter].
   ir.FunctionDefinition makeFunctionDefinition(
       List<ConstantExpression> defaults) {
     FunctionElement element = state.currentElement;
     if (element.isAbstract || element.isExternal) {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
                 element, state.functionParameters, defaults);
     } else {
-      _ensureReturn();
+      ir.RunnableBody body = makeRunnableBody();
       return new ir.FunctionDefinition(
-          element, state.returnContinuation, state.functionParameters, _root,
+          element, state.functionParameters, body,
           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);
+    }
+    ir.RunnableBody body = makeRunnableBody();
+    return new ir.ConstructorDefinition(
+        element, state.functionParameters, body, initializers,
+        state.localConstants, defaults, element.isConst,

[Kevin Millikin (Google), 2014/12/11 09:28:25]

Since we're passing in element, maybe it's better to just take isConst from the
element instead of requiring passing it.  Or you could make
ConstructorDefinition.isConst a getter that uses element.isConst.

Or do you think we will ever want to pass a value to the constructor that
disagrees with element.isConst?

[sigurdm, 2014/12/17 10:20:56]

Removed the isConst property from tre_ir and cps_ir, just reading it from the
element when it is needed.

+        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].
   ir.Primitive buildSuperInvocation(Selector selector,
                                     List<ir.Primitive> arguments) {
     return _buildInvokeSuper(selector, arguments);
   }
 
   /// Create a getter invocation on the super class where the getter name is
   /// defined by [selector].
@@ skipping 886 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }