Generative constructors in the new dart backend.

pkg/compiler/lib/src/tree_ir/optimization/copy_propagator.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.
 
 part of tree_ir.optimization;
 
 /// Eliminates moving assignments, such as w := v, by assigning directly to w
 /// at the definition of v.
 ///
 /// This compensates for suboptimal register allocation, and merges closure
@@ skipping 10 matching lines @@
   /// Like [move], except w is the key instead of v.
   Map<Variable, Assign> inverseMove = <Variable, Assign>{};
 
   ExecutableElement currentElement;
 
   void rewriteExecutableDefinition(ExecutableDefinition root) {
     currentElement = root.element;
     root.body = visitStatement(root.body);
   }
 
-  rewriteFunctionDefinition(FunctionDefinition function) {
-    if (function.isAbstract) return;
-    rewriteExecutableDefinition(function);
+  rewriteFunctionDefinition(FunctionDefinition node) {
+    if (node.isAbstract) return;
+    rewriteExecutableDefinition(node);
 
     // Try to propagate moving assignments into function parameters.
     // For example:
     // foo(x) {
     //   var v1 = x;
     //   BODY
     // }
     //   ==>
     // foo(v1) {
     //   BODY
     // }
 
     // Variables must not occur more than once in the parameter list, so
     // invalidate all moving assignments that would propagate a parameter
     // into another parameter. For example:
     // foo(x,y) {
     //   y = x;
     //   BODY
     // }
     // Cannot declare function as foo(x,x)!
-    function.parameters.forEach(visitVariable);
+    node.parameters.forEach(visitVariable);
 
     // Now do the propagation.
-    for (int i = 0; i < function.parameters.length; i++) {
-      Variable param = function.parameters[i];
+    for (int i = 0; i < node.parameters.length; i++) {
+      Variable param = node.parameters[i];
       Variable replacement = copyPropagateVariable(param);
       replacement.element = param.element; // Preserve parameter name.
-      function.parameters[i] = replacement;
+      node.parameters[i] = replacement;
     }
   }
 
+  rewriteConstructorDefinition(ConstructorDefinition node) {
+    if (node.isAbstract) return;
+    node.initializers.forEach(visitExpression);
+    rewriteExecutableDefinition(node);
+
+
+    // Try to propagate moving assignments into function parameters.
+    // For example:
+    // foo(x) {
+    //   var v1 = x;
+    //   BODY
+    // }
+    //   ==>
+    // foo(v1) {
+    //   BODY
+    // }
+
+    // Variables must not occur more than once in the parameter list, so
+    // invalidate all moving assignments that would propagate a parameter
+    // into another parameter. For example:
+    // foo(x,y) {
+    //   y = x;
+    //   BODY
+    // }
+    // Cannot declare function as foo(x,x)!
+    node.parameters.forEach(visitVariable);
+
+    // Now do the propagation.
+    for (int i = 0; i < node.parameters.length; i++) {
+      Variable param = node.parameters[i];
+      Variable replacement = copyPropagateVariable(param);
+      replacement.element = param.element; // Preserve parameter name.
+      node.parameters[i] = replacement;
+    }
+
+  }
+
+
   Statement visitBasicBlock(Statement node) {
     node = visitStatement(node);
     move.clear();
     inverseMove.clear();
     return node;
   }
 
   void visitVariable(Variable variable) {
     // We have found a use of w.
     // Remove assignments of form w := v from the move maps.
@@ skipping 108 matching lines @@
   Statement visitExpressionStatement(ExpressionStatement node) {
     node.next = visitStatement(node.next);
     visitExpression(node.expression);
     return node;
   }
 
   void visitFunctionExpression(FunctionExpression node) {
     new CopyPropagator().rewrite(node.definition);
   }
 
+  void visitFieldInitializer(FieldInitializer node) {
+    visitStatement(node.body);
+  }
+
 }