Add support for fields to the new dart backend.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
 import '../dart2jslib.dart' as dart2js show invariant;
 import '../elements/elements.dart';
 import '../universe/universe.dart' show Selector, SelectorKind;
 import '../dart_types.dart' show DartType, GenericType;
+import '../cps_ir/optimizers.dart';
 
 abstract class Node {
   /// A pointer to the parent node. Is null until set by optimization passes.
   Node parent;
 
   accept(Visitor visitor);
 }
 
 abstract class Expression extends Node {
   Expression plug(Expression expr) => throw 'impossible';
@@ skipping 518 matching lines @@
 
   bool get isReturnContinuation => body == null;
 
   Continuation(this.parameters);
 
   Continuation.retrn() : parameters = <Parameter>[new Parameter(null)];
 
   accept(Visitor visitor) => visitor.visitContinuation(this);
 }
 
+abstract class ExecutableDefinition implements Node {
+  Expression get body;
+
+  applyPass(Pass pass);
+}
+
+// This is basically a function definition with an empty parameter list and a
+// field element instead of a function element and no const declarations, and
+// never a getter or setter, though that's less important.
+class FieldDefinition extends Node
+    implements InteriorNode, ExecutableDefinition {
+  final FieldElement element;
+  final Continuation returnContinuation;
+  Expression body;
+
+  FieldDefinition(this.element, this.returnContinuation, this.body);
+  accept(Visitor visitor) => visitor.visitFieldDefinition(this);
+  applyPass(Pass pass) => pass.rewriteFieldDefinition(this);
+}
+
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter.
-class FunctionDefinition extends Node implements InteriorNode {
+class FunctionDefinition extends Node
+    implements InteriorNode, ExecutableDefinition {
   final FunctionElement element;
   final Continuation returnContinuation;
   final List<Parameter> parameters;
   Expression body;
   final List<ConstDeclaration> localConstants;
 
   /// Values for optional parameters.
   final List<ConstantExpression> defaultParameterValues;
 
   FunctionDefinition(this.element, this.returnContinuation,
       this.parameters, this.body, this.localConstants,
       this.defaultParameterValues);
 
   FunctionDefinition.abstract(this.element,
                               this.parameters,
                               this.defaultParameterValues)
       : this.returnContinuation = null,
         this.localConstants = const <ConstDeclaration>[];
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
+  applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract or external.
   ///
   /// If `true`, [body] and [returnContinuation] are `null` and [localConstants]
   /// is empty.
   bool get isAbstract => body == null;
 }
 
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node) => node.accept(this);
   // Abstract classes.
   T visitNode(Node node) => null;
   T visitExpression(Expression node) => visitNode(node);
   T visitDefinition(Definition node) => visitNode(node);
   T visitPrimitive(Primitive node) => visitDefinition(node);
   T visitCondition(Condition node) => visitNode(node);
 
   // Concrete classes.
+  T visitFieldDefinition(FieldDefinition node) => visitNode(node);
   T visitFunctionDefinition(FunctionDefinition node) => visitNode(node);
 
   // Expressions.
   T visitLetPrim(LetPrim node) => visitExpression(node);
   T visitLetCont(LetCont node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
   T visitInvokeSuperMethod(InvokeSuperMethod node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
@@ skipping 29 matching lines @@
   // Ensures that RecursiveVisitor contains overrides for all relevant nodes.
   // As a rule of thumb, nodes with structure to traverse should be overridden
   // with the appropriate visits in this class (for example, visitLetCont),
   // while leaving other nodes for subclasses (i.e., visitLiteralList).
   visitNode(Node node) {
     throw "RecursiveVisitor is stale, add missing visit overrides";
   }
 
   processReference(Reference ref) {}
 
+  processFieldDefinition(FieldDefinition node) {}
+  visitFieldDefinition(FieldDefinition node) {
+    processFieldDefinition(node);
+    visit(node.body);
+  }
+
   processFunctionDefinition(FunctionDefinition node) {}
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
     node.parameters.forEach(visitParameter);
     visit(node.body);
   }
 
   // Expressions.
 
   processLetPrim(LetPrim node) {}
@@ skipping 46 matching lines @@
     node.arguments.forEach(processReference);
   }
 
   processConcatenateStrings(ConcatenateStrings node) {}
   visitConcatenateStrings(ConcatenateStrings node) {
     processConcatenateStrings(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
-
   processBranch(Branch node) {}
   visitBranch(Branch node) {
     processBranch(node);
     processReference(node.trueContinuation);
     processReference(node.falseContinuation);
     visit(node.condition);
   }
 
   processTypeOperator(TypeOperator node) {}
   visitTypeOperator(TypeOperator node) {
@@ skipping 130 matching lines @@
     if (primitive.hint == null) return;
     if (primitive.registerIndex != null) {
       getRegisterArray(primitive.hint).releaseIndex(primitive.registerIndex);
     }
   }
 
   void visitReference(Reference reference) {
     allocate(reference.definition);
   }
 
+  void visitFieldDefinition(FieldDefinition node) {
+    visit(node.body);
+  }
+
   void visitFunctionDefinition(FunctionDefinition node) {
     if (!node.isAbstract) {
       visit(node.body);
     }
     node.parameters.forEach(allocate); // Assign indices to unused parameters.
-    elementRegisters.clear();
   }
 
   void visitLetPrim(LetPrim node) {
     visit(node.body);
     release(node.primitive);
     visit(node.primitive);
   }
 
   void visitLetCont(LetCont node) {
     visit(node.continuation);
@@ skipping 90 matching lines @@
   }
 
   // JavaScript specific nodes.
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 }