Generative constructors in the new dart backend.

pkg/compiler/lib/src/cps_ir/constant_propagation.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 dart2js.optimizers;
+part of dart2js.cps_ir.optimizers;
 
 /**
  * Propagates constants throughout the IR, and replaces branches with fixed
  * jumps as well as side-effect free expressions with known constant results.
  * Should be followed by the [ShrinkingReducer] pass.
  *
  * Implemented according to 'Constant Propagation with Conditional Branches'
  * by Wegman, Zadeck.
  */
-class ConstantPropagator extends Pass {
+class ConstantPropagator extends PassMixin {
 
   // Required for type determination in analysis of TypeOperator expressions.
   final dart2js.Compiler _compiler;
 
   // The constant system is used for evaluation of expressions with constant
   // arguments.
   final dart2js.ConstantSystem _constantSystem;
 
   ConstantPropagator(this._compiler, this._constantSystem);
 
-  void _rewriteExecutableDefinition(ExecutableDefinition root) {
+  @override
+  void rewriteExecutableDefinition(ExecutableDefinition root) {
     // Set all parent pointers.
     new ParentVisitor().visit(root);
 
     // Analyze. In this phase, the entire term is analyzed for reachability
     // and the constant status of each expression.
 
     _ConstPropagationVisitor analyzer =
         new _ConstPropagationVisitor(_compiler, _constantSystem);
     analyzer.analyze(root);
 
     // Transform. Uses the data acquired in the previous analysis phase to
     // replace branches with fixed targets and side-effect-free expressions
     // with constant results.
 
     _TransformingVisitor transformer = new _TransformingVisitor(
         analyzer.reachableNodes, analyzer.node2value);
     transformer.transform(root);
   }
 
-  void rewriteFunctionDefinition(FunctionDefinition root) {
-    if (root.isAbstract) return;
-    _rewriteExecutableDefinition(root);
-  }
-
-  void rewriteFieldDefinition(FieldDefinition root) {
-    if (!root.hasInitializer) return;
-    _rewriteExecutableDefinition(root);
-  }
-
 }
 
 /**
  * Uses the information from a preceding analysis pass in order to perform the
  * actual transformations on the CPS graph.
  */
 class _TransformingVisitor extends RecursiveVisitor {
 
   final Set<Node> reachable;
   final Map<Node, _ConstnessLattice> node2value;
@@ skipping 234 matching lines @@
     }
   }
 
   // -------------------------- Visitor overrides ------------------------------
 
   void visitNode(Node node) {
     compiler.internalError(NO_LOCATION_SPANNABLE,
         "_ConstPropagationVisitor is stale, add missing visit overrides");
   }
 
+  void visitRunnableBody(RunnableBody node) {
+    setReachable(node.body);
+  }
+
   void visitFunctionDefinition(FunctionDefinition node) {
     node.parameters.forEach(visit);
     setReachable(node.body);
   }
 
   void visitFieldDefinition(FieldDefinition node) {
     if (node.hasInitializer) {
       setReachable(node.body);
     }
   }
@@ skipping 376 matching lines @@
       return that;
     }
 
     if (this.constant == that.constant) {
       return this;
     }
 
     return NonConst;
   }
 }