Add support for fields to the new dart backend.

pkg/compiler/lib/src/dart_backend/backend_ast_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 backend_ast_nodes;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' as types;
 import '../elements/elements.dart' as elements;
 import '../tree/tree.dart' as tree;
 import '../util/characters.dart' as characters;
 
 /// The following nodes correspond to [tree.Send] expressions:
 /// [FieldExpression], [IndexExpression], [Assignment], [Increment],
 /// [CallFunction], [CallMethod], [CallNew], [CallStatic], [UnaryOperator],
 /// [BinaryOperator], and [TypeOperator].
 abstract class Node {}
 
 /// Receiver is an [Expression] or the [SuperReceiver].
 abstract class Receiver extends Node {}
 
 /// Argument is an [Expression] or a [NamedArgument].
 abstract class Argument extends Node {}
 
 abstract class Expression extends Node implements Receiver, Argument {
   bool get assignable => false;
 }
 
+abstract class ExecutableDefinition extends Node {
+  elements.Element get element;
+}
+
+class FieldDefinition extends ExecutableDefinition {
+  final elements.Element element;
+  final Expression initializer;
+  FieldDefinition(this.element, this.initializer);
+}
+
 abstract class Statement extends Node {}
 
 /// Used as receiver in expressions that dispatch to the super class.
 /// For instance, an expression such as `super.f()` is represented
 /// by a [CallMethod] node with [SuperReceiver] as its receiver.
 class SuperReceiver extends Receiver {
   static final SuperReceiver _instance = new SuperReceiver._create();
 
   factory SuperReceiver() => _instance;
   SuperReceiver._create();
@@ skipping 250 matching lines @@
                      [ this.defaultValue ]) : type = returnType {
     assert(parameters != null);
   }
 
   /// True if this is a function parameter.
   bool get isFunction => parameters != null;
 }
 
 // EXPRESSIONS
 
-class FunctionExpression extends Expression {
+class FunctionExpression extends Expression implements ExecutableDefinition {
   final TypeAnnotation returnType;
   String name;
   final Parameters parameters;
   final Statement body;
   final bool isGetter;
   final bool isSetter;
 
   elements.FunctionElement element;
 
   FunctionExpression(this.parameters,
@@ skipping 1225 matching lines @@
   final StringChunk previous;
   final tree.StringQuoting quoting;
   num cost;
 
   OpenStringChunk(this.previous, this.quoting, this.cost);
 
   StringChunk end(int endIndex) {
     return new StringChunk(previous, quoting, endIndex);
   }
 }