Add support for fields to the new dart backend.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 173 matching lines @@
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors = <JumpCollector>[];
 
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors = <JumpCollector>[];
 
   final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
 
   final Iterable<Entity> closureLocals;
 
-  final FunctionElement currentFunction;
+  final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
 
   IrBuilderSharedState(this.constantSystem,
-                       this.currentFunction,
+                       this.currentElement,
                        this.closureLocals);
 }
 
 /// A factory for building the cps IR.
 class IrBuilder {
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
 
@@ skipping 23 matching lines @@
   //
   // We do not pass contexts as arguments or return them.  Rather we use the
   // current context (root, current) as the visitor state and mutate current.
   // Visiting a statement returns null; visiting an expression returns the
   // primitive denoting its value.
 
   ir.Expression _root = null;
   ir.Expression _current = null;
 
   IrBuilder(ConstantSystem constantSystem,
-            FunctionElement currentFunction,
+            ExecutableElement currentElement,
             Iterable<Entity> closureLocals)
       : this.state = new IrBuilderSharedState(
-            constantSystem, currentFunction, closureLocals),
+            constantSystem, currentElement, closureLocals),
         this.environment = new Environment.empty();
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// The delimited visitor has its own compile-time environment mapping
   /// local variables to their values, which is initially a copy of the parent
   /// environment.  It has its own context for building an IR expression, so
   /// the built expression is not plugged into the parent's context.
   IrBuilder.delimited(IrBuilder parent)
       : this.state = parent.state,
@@ skipping 269 matching lines @@
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = buildNullLiteral();
     add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
   }
 
+  /// Create a [ir.FieldDefinition] for the current [Element] using [_root] as
+  /// the body.
+  ir.FieldDefinition makeFieldDefinition() {
+    return new ir.FieldDefinition(state.currentElement,
+                                  state.returnContinuation,
+                                  _root);
+  }
+
   /// Create a [ir.FunctionDefinition] for [element] using [_root] as the body.
   ///
   /// Parameters must be created before the construction of the body using
   /// [createParameter].
   ir.FunctionDefinition buildFunctionDefinition(
-      FunctionElement element,
       List<ConstantExpression> defaults) {
+    FunctionElement element = state.currentElement;
     if (element.isAbstract || element.isExternal) {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
                 element, _parameters, defaults);
     } else {
       _ensureReturn();
@@ skipping 901 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }