Add support for fields to the new dart backend.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 39 matching lines @@
       <Element,List<Variable>>{};
 
   /// Like [element2variables], except for closure variables. Closure variables
   /// are not subject to SSA, so at most one variable is used per local.
   final Map<Local, Variable> local2closure = <Local, Variable>{};
 
   // Continuations with more than one use are replaced with Tree labels.  This
   // is the mapping from continuations to labels.
   final Map<cps_ir.Continuation, Label> labels = <cps_ir.Continuation, Label>{};
 
-  FunctionDefinition function;
+  ExecutableElement currentElement;
   cps_ir.Continuation returnContinuation;
 
   Builder parent;
 
   Builder(this.compiler);
 
   Builder.inner(Builder parent)
       : this.parent = parent,
         compiler = parent.compiler;
 
   /// Variable used in [buildPhiAssignments] as a temporary when swapping
   /// variables.
   Variable phiTempVar;
 
   Variable getClosureVariable(Local local) {
-    if (local.executableContext != function.element) {
+    if (local.executableContext != currentElement) {
       return parent.getClosureVariable(local);
     }
     Variable variable = local2closure[local];
     if (variable == null) {
-      variable = new Variable(function, local);
+      variable = new Variable(currentElement, local);
       local2closure[local] = variable;
     }
     return variable;
   }
 
   /// Obtains the variable representing the given primitive. Returns null for
   /// primitives that have no reference and do not need a variable.
   Variable getVariable(cps_ir.Primitive primitive) {
     if (primitive.registerIndex == null) {
       return null; // variable is unused
     }
     List<Variable> variables = element2variables[primitive.hint];
     if (variables == null) {
       variables = <Variable>[];
       element2variables[primitive.hint] = variables;
     }
     while (variables.length <= primitive.registerIndex) {
-      variables.add(new Variable(function, primitive.hint));
+      variables.add(new Variable(currentElement, primitive.hint));
     }
     return variables[primitive.registerIndex];
   }
 
   /// Obtains a reference to the tree Variable corresponding to the IR primitive
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
   Expression getVariableReference(cps_ir.Reference reference) {
     Variable variable = getVariable(reference.definition);
     if (variable == null) {
       compiler.internalError(
           compiler.currentElement,
           "Reference to ${reference.definition} has no register");
     }
     ++variable.readCount;
     return variable;
   }
 
-  FunctionDefinition build(cps_ir.FunctionDefinition node) {
-    visit(node);
-    return function;
+  ExecutableDefinition build(cps_ir.ExecutableDefinition node) {
+    if (node is cps_ir.FieldDefinition) {
+      return buildField(node);
+    } else if (node is cps_ir.FunctionDefinition) {
+      return buildFunction(node);
+    }
+    assert(false);
+  }
+
+  FieldDefinition buildField(cps_ir.FieldDefinition node) {
+    currentElement = node.element;
+    returnContinuation = node.returnContinuation;
+
+    phiTempVar = new Variable(node.element, null);
+
+    return new FieldDefinition(node.element, visit(node.body));
+  }
+
+  FunctionDefinition buildFunction(cps_ir.FunctionDefinition node) {
+    currentElement = node.element;
+    List<Variable> parameters = <Variable>[];
+    for (cps_ir.Parameter p in node.parameters) {
+      Variable parameter = getVariable(p);
+      assert(parameter != null);
+      ++parameter.writeCount; // Being a parameter counts as a write.
+      parameters.add(parameter);
+    }
+    returnContinuation = node.returnContinuation;
+
+    Statement body;
+    if (!node.isAbstract) {
+      phiTempVar = new Variable(node.element, null);
+      body = visit(node.body);
+    }
+
+    return new FunctionDefinition(node.element, parameters,
+        body, node.localConstants, node.defaultParameterValues);
   }
 
   List<Expression> translateArguments(List<cps_ir.Reference> args) {
     return new List<Expression>.generate(args.length,
          (int index) => getVariableReference(args[index]));
   }
 
   List<Variable> translatePhiArguments(List<cps_ir.Reference> args) {
     return new List<Variable>.generate(args.length,
          (int index) => getVariableReference(args[index]));
@@ skipping 93 matching lines @@
     if (first == null) {
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
   }
 
   visitNode(cps_ir.Node node) => throw "Unhandled node: $node";
 
-  Expression visitFunctionDefinition(cps_ir.FunctionDefinition node) {
-    List<Variable> parameters = <Variable>[];
-    function = new FunctionDefinition(node.element, parameters,
-        null, node.localConstants, node.defaultParameterValues);
-    returnContinuation = node.returnContinuation;
-    for (cps_ir.Parameter p in node.parameters) {
-      Variable parameter = getVariable(p);
-      assert(parameter != null);
-      ++parameter.writeCount; // Being a parameter counts as a write.
-      parameters.add(parameter);
-    }
-    if (!node.isAbstract) {
-      phiTempVar = new Variable(function, null);
-      function.body = visit(node.body);
-    }
-    return null;
-  }
-
   Statement visitLetPrim(cps_ir.LetPrim node) {
     Variable variable = getVariable(node.primitive);
 
     // Don't translate unused primitives.
     if (variable == null) return visit(node.body);
 
     Node definition = visit(node.primitive);
 
     // visitPrimitive returns a Statement without successor if it cannot occur
     // in expression context (currently only the case for FunctionDeclarations).
@@ skipping 170 matching lines @@
         node.type,
         new List<LiteralMapEntry>.generate(node.entries.length, (int index) {
           return new LiteralMapEntry(
               getVariableReference(node.entries[index].key),
               getVariableReference(node.entries[index].value));
         })
     );
   }
 
   FunctionDefinition makeSubFunction(cps_ir.FunctionDefinition function) {
-    return new Builder.inner(this).build(function);
+    return new Builder.inner(this).buildFunction(function);
   }
 
   Node visitCreateFunction(cps_ir.CreateFunction node) {
     FunctionDefinition def = makeSubFunction(node.definition);
     FunctionType type = node.definition.element.type;
     bool hasReturnType = !type.returnType.treatAsDynamic;
     if (hasReturnType) {
       // This function cannot occur in expression context.
       // The successor will be filled in by visitLetPrim.
       return new FunctionDeclaration(getVariable(node), def, null);
@@ skipping 26 matching lines @@
 
   Expression visitIdentical(cps_ir.Identical node) {
     return new InvokeStatic(
         compiler.identicalFunction,
         identicalSelector,
         <Expression>[getVariableReference(node.left),
                      getVariableReference(node.right)]);
   }
 }