Add support for fields to the new dart backend.

pkg/compiler/lib/src/dart_backend/backend_ast_to_frontend_ast.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 dart_tree_printer;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' as types;
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart' as elements;
 import '../tree/tree.dart' as tree;
 import '../scanner/scannerlib.dart';
 import '../util/util.dart';
 import 'backend_ast_nodes.dart';
 import 'backend_ast_emitter.dart' show createTypeAnnotation;
 
 /// Translates the backend AST to Dart frontend AST.
-tree.FunctionExpression emit(dart2js.TreeElementMapping treeElements,
-                             Node definition) {
-  return new TreePrinter(treeElements).makeExpression(definition);
+tree.Node emit(dart2js.TreeElementMapping treeElements,
+               ExecutableDefinition definition) {
+  return new TreePrinter(treeElements).makeDefinition(definition);
 }
 
 /// If true, the unparser will insert a coment in front of every function
 /// it emits. This helps indicate which functions were translated by the new
 /// backend.
 bool INSERT_NEW_BACKEND_COMMENT =
     const bool.fromEnvironment('USE_NEW_BACKEND', defaultValue: false);
 
 /// Converts backend ASTs to frontend ASTs.
 class TreePrinter {
   dart2js.TreeElementMapping treeElements;
 
   TreePrinter([this.treeElements]);
 
+  tree.Node makeDefinition(ExecutableDefinition node) {
+    if (node is FieldDefinition) {
+      tree.Node definition;
+      if (node.initializer == null) {
+        definition = makeIdentifier(node.element.name);
+      } else {
+        definition = new tree.SendSet(
+            null,
+            makeIdentifier(node.element.name),
+            new tree.Operator(assignmentToken("=")),
+            singleton(makeExpression(node.initializer)));
+      }
+      setElement(definition, node.element, node);
+      return new tree.VariableDefinitions(
+          null, // TODO(sigurdm): Type
+          makeVarModifiers(useVar: true,
+                           isFinal: node.element.isFinal,
+                           isStatic: node.element.isStatic,
+                           isConst: node.element.isConst),
+          makeList(null, [definition], close: semicolon));
+    } else if (node is FunctionExpression) {
+      return makeExpression(node);
+    } else {
+      assert(false);
+      return null;
+    }
+  }
+
   void setElement(tree.Node node, elements.Element element, source) {
     if (treeElements != null) {
       if (element == null) {
         throw "Missing element from ${source}";
       }
       treeElements[node] = element;
     }
   }
 
   void setType(tree.Node node, types.DartType type, source) {
@@ skipping 366 matching lines @@
       result = new tree.FunctionExpression(
           functionName(exp),
           parameters,
           body,
           exp.returnType == null || exp.element.isConstructor
             ? null
             : makeType(exp.returnType),
           makeFunctionModifiers(exp),
           null,  // initializers
           getOrSet,  // get/set
-          null); // async modifier
-      setElement(result, exp.element, exp);
+          null);  // async modifier
+      elements.Element element = exp.element;
+      if (element != null) setElement(result, element, exp);
     } else if (exp is Identifier) {
       precedence = CALLEE;
       result = new tree.Send(
           makeStaticReceiver(exp.element),
           makeIdentifier(exp.name));
       setElement(result, exp.element, exp);
     } else if (exp is Increment) {
       Expression lvalue = exp.expression;
       tree.Node receiver;
       tree.Node selector;
@@ skipping 522 matching lines @@
     }
     if (isConst) {
       nodes.add(makeIdentifier('const'));
     }
     if (isFinal) {
       nodes.add(makeIdentifier('final'));
     }
     if (isVar) {
       nodes.add(makeIdentifier('var'));
     }
-    return new tree.Modifiers(makeList('', nodes));
+    return new tree.Modifiers(makeList(' ', nodes));
   }
 
   tree.Modifiers makeVarModifiers({bool isConst: false,
                                    bool isFinal: false,
-                                   bool useVar: false}) {
-    return makeModifiers(isConst: isConst,
+                                   bool useVar: false,
+                                   bool isStatic: false}) {
+    return makeModifiers(isStatic: isStatic,
+                         isConst: isConst,
                          isFinal: isFinal,
                          isVar: useVar && !(isConst || isFinal));
   }
 
   tree.Modifiers makeFunctionModifiers(FunctionExpression exp) {
     if (exp.element == null) return makeEmptyModifiers();
     return makeModifiers(isExternal: exp.element.isExternal,
                          isStatic: exp.element.isStatic,
                          isFactory: exp.element.isFactoryConstructor);
   }
@@ skipping 231 matching lines @@
             printStringChunk(chunk.previous),
             node);
       } else {
         return node;
       }
     }
     return printStringChunk(output.chunk);
   }
 
 }