Add support for fields to the new dart backend.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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.
 
 library tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../dart_types.dart' show DartType, GenericType;
 import '../elements/elements.dart';
 import '../universe/universe.dart';
 import '../universe/universe.dart' show Selector;
+import 'optimization/optimization.dart';
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
 // unnecessary names, recognizing high-level control constructs.  Combining
 // these separate concerns is complicated and the constraints of the CPS-based
 // language do not permit a multi-stage translation.
 //
 // For that reason, CPS is translated to the direct-style language Tree.
@@ skipping 55 matching lines @@
 
   /// The [LabeledStatement] or [WhileTrue] binding this label.
   JumpTarget binding;
 }
 
 /**
  * Variables are [Expression]s.
  */
 class Variable extends Expression {
   /// Function that declares this variable.
-  FunctionDefinition host;
+  ExecutableElement host;
 
   /// [Entity] used for synthesizing a name for the variable.
   /// Different variables may have the same entity. May be null.
   Entity element;
 
   int readCount = 0;
 
   /// Number of places where this variable occurs as:
   /// - left-hand of an [Assign]
   /// - left-hand of a [FunctionDeclaration]
@@ skipping 385 matching lines @@
 
 class ExpressionStatement extends Statement {
   Statement next;
   Expression expression;
 
   ExpressionStatement(this.expression, this.next);
 
   accept(StatementVisitor visitor) => visitor.visitExpressionStatement(this);
 }
 
-class FunctionDefinition extends Node {
+abstract class ExecutableDefinition {
+  ExecutableElement get element;
+  Statement body;
+
+  applyPass(Pass pass);
+}
+
+class FieldDefinition extends Node implements ExecutableDefinition {
+  final FieldElement element;
+  // The `body` of a field is its initializer.
+  Statement body;
+
+  FieldDefinition(this.element, this.body);
+  applyPass(Pass pass) => pass.rewriteFieldDefinition(this);
+}
+
+class FunctionDefinition extends Node implements ExecutableDefinition {
   final FunctionElement element;
   final List<Variable> parameters;
   Statement body;
   final List<ConstDeclaration> localConstants;
   final List<ConstantExpression> defaultParameterValues;
 
   FunctionDefinition(this.element, this.parameters, this.body,
       this.localConstants, this.defaultParameterValues);
 
   /// Returns `true` if this function is abstract.
   ///
   /// If `true` [body] is `null` and [localConstants] is empty.
   bool get isAbstract => body == null;
+  applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 }
 
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeSuperMethod(InvokeSuperMethod node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
@@ skipping 135 matching lines @@
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitFunctionDefinition(node.definition);
     visitStatement(node.next);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
     visitStatement(node.next);
   }
 }