Add support for fields to 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;
 
 /**
  * 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 implements Pass {
+class ConstantPropagator extends Pass {
 
   // 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 rewrite(FunctionDefinition root) {
-    if (root.isAbstract) return;
-
+  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) {
+    _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;
 
   _TransformingVisitor(this.reachable, this.node2value);
 
-  void transform(FunctionDefinition root) {
-    visitFunctionDefinition(root);
+  void transform(ExecutableDefinition root) {
+    visit(root);
   }
 
   /// Given an expression with a known constant result and a continuation,
   /// replaces the expression by a new LetPrim / InvokeContinuation construct.
   /// `unlink` is a closure responsible for unlinking all removed references.
   LetPrim constifyExpression(Expression node,
                              Continuation continuation,
                              void unlink()) {
     _ConstnessLattice cell = node2value[node];
     if (cell == null || !cell.isConstant) {
@@ skipping 146 matching lines @@
   final dart2js.Compiler compiler;
   final dart2js.ConstantSystem constantSystem;
 
   // Stores the current lattice value for nodes. Note that it contains not only
   // definitions as keys, but also expressions such as method invokes.
   // Access through [getValue] and [setValue].
   final Map<Node, _ConstnessLattice> node2value = <Node, _ConstnessLattice>{};
 
   _ConstPropagationVisitor(this.compiler, this.constantSystem);
 
-  void analyze(FunctionDefinition root) {
+  void analyze(ExecutableDefinition root) {
     reachableNodes.clear();
     defWorkset.clear();
     nodeWorklist.clear();
 
     // Initially, only the root node is reachable.
     setReachable(root);
 
     while (true) {
       if (nodeWorklist.isNotEmpty) {
         // Process a new reachable expression.
@@ skipping 57 matching lines @@
   void visitNode(Node node) {
     compiler.internalError(NO_LOCATION_SPANNABLE,
         "_ConstPropagationVisitor is stale, add missing visit overrides");
   }
 
   void visitFunctionDefinition(FunctionDefinition node) {
     node.parameters.forEach(visitParameter);
     setReachable(node.body);
   }
 
+  void visitFieldDefinition(FieldDefinition node) {
+    setReachable(node.body);
+  }
+
   // Expressions.
 
   void visitLetPrim(LetPrim node) {
     visit(node.primitive); // No reason to delay visits to primitives.
     setReachable(node.body);
   }
 
   void visitLetCont(LetCont node) {
     // The continuation is only marked as reachable on use.
     setReachable(node.body);
@@ skipping 362 matching lines @@
       return that;
     }
 
     if (this.constant == that.constant) {
       return this;
     }
 
     return NonConst;
   }
 }