Add support for fields to the new dart backend.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.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_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' as modelx;
 import '../universe/universe.dart';
 import '../tree/tree.dart' as tree show Modifiers;
 
 /// Translates the dart_tree IR to Dart backend AST.
-Expression emit(tree.FunctionDefinition definition) {
+ExecutableDefinition emit(tree.ExecutableDefinition definition) {
   return new ASTEmitter().emit(definition);
 }
 
 /// Translates the dart_tree IR to Dart backend AST.
 /// An instance of this class should only be used once; a fresh emitter
 /// must be created for each function to be emitted.
 class ASTEmitter extends tree.Visitor<dynamic, Expression> {
   /// Variables to be hoisted at the top of the current function.
   List<VariableDeclaration> variables = <VariableDeclaration>[];
 
   /// Maps variables to their name.
   Map<tree.Variable, String> variableNames = <tree.Variable, String>{};
 
   /// Maps local constants to their name.
   Map<VariableElement, String> constantNames = <VariableElement, String>{};
 
   /// Variables that have had their declaration created.
   Set<tree.Variable> declaredVariables = new Set<tree.Variable>();
 
   /// Variable names that have already been used. Used to avoid name clashes.
   Set<String> usedVariableNames;
 
   /// Statements emitted by the most recent call to [visitStatement].
   List<Statement> statementBuffer = <Statement>[];
 
-  /// The function currently being emitted.
-  FunctionElement functionElement;
+  /// The element currently being emitted.
+  ExecutableElement currentElement;
 
   /// Bookkeeping object needed to synthesize a variable declaration.
   modelx.VariableList variableList
       = new modelx.VariableList(tree.Modifiers.EMPTY);
 
   /// Input to [visitStatement]. Denotes the statement that will execute next
   /// if the statements produced by [visitStatement] complete normally.
   /// Set to null if control will fall over the end of the method.
   tree.Statement fallthrough = null;
 
   /// Labels that could not be eliminated using fallthrough.
   Set<tree.Label> usedLabels = new Set<tree.Label>();
 
   /// The first dart_tree statement that is not converted to a variable
   /// initializer.
   tree.Statement firstStatement;
 
   /// Emitter for the enclosing function, or null if the current function is
   /// not a local function.
   ASTEmitter parent;
 
   ASTEmitter() : usedVariableNames = new Set<String>();
 
   ASTEmitter.inner(ASTEmitter parent)
       : this.parent = parent,
         usedVariableNames = parent.usedVariableNames;
 
-  FunctionExpression emit(tree.FunctionDefinition definition) {
-    functionElement = definition.element;
+  ExecutableDefinition emit(tree.ExecutableDefinition definition) {
+    if (definition is tree.FieldDefinition) {
+      return emitField(definition);
+    }
+    assert(definition is tree.FunctionDefinition);
+    return emitFunction(definition);
+  }
+
+  FieldDefinition emitField(tree.FieldDefinition definition) {
+    currentElement = definition.element;
+    visitStatement(definition.body);
+    List<Statement> bodyParts;
+    for (tree.Variable variable in variableNames.keys) {
+      if (!declaredVariables.contains(variable)) {
+        addDeclaration(variable);
+      }
+    }
+    if (variables.length > 0) {
+      bodyParts = new List<Statement>();
+      bodyParts.add(new VariableDeclarations(variables));
+      bodyParts.addAll(statementBuffer);
+    } else {
+      bodyParts = statementBuffer;
+    }
+
+    return new FieldDefinition(definition.element, ensureExpression(bodyParts));
+  }
+
+  /// Returns an expression that will evaluate all of [bodyParts].
+  /// If [bodyParts] is a single [Return] return its value.
+  /// Otherwise wrap the body-parts in an immediately invoked closure.
+  Expression ensureExpression(List<Statement> bodyParts) {
+    if (bodyParts.length == 1) {
+      Statement onlyStatement = bodyParts.single;
+      if (onlyStatement is Return) {
+        return onlyStatement.expression;
+      }
+    }
+    Statement body = new Block(bodyParts);
+    FunctionExpression function =
+        new FunctionExpression(new Parameters([]), body);
+    function.element = null;
+    return new CallFunction(function, []);
+  }
+
+  FunctionExpression emitFunction(tree.FunctionDefinition definition) {
+    currentElement = definition.element;
 
     Parameters parameters = emitRootParameters(definition);
 
     // Declare parameters.
     for (tree.Variable param in definition.parameters) {
       variableNames[param] = param.element.name;
       usedVariableNames.add(param.element.name);
       declaredVariables.add(param);
     }
 
@@ skipping 30 matching lines @@
       if (constants.length > 0) {
         bodyParts.add(new VariableDeclarations(constants, isConst: true));
       }
       if (variables.length > 0) {
         bodyParts.add(new VariableDeclarations(variables));
       }
       bodyParts.addAll(statementBuffer);
 
       body = new Block(bodyParts);
     }
-    FunctionType functionType = functionElement.type;
+    FunctionType functionType = currentElement.type;
 
     return new FunctionExpression(
         parameters,
         body,
-        name: functionElement.name,
+        name: currentElement.name,
         returnType: emitOptionalType(functionType.returnType),
-        isGetter: functionElement.isGetter,
-        isSetter: functionElement.isSetter)
-        ..element = functionElement;
+        isGetter: currentElement.isGetter,
+        isSetter: currentElement.isSetter)
+        ..element = currentElement;
   }
 
   void addDeclaration(tree.Variable variable, [Expression initializer]) {
     assert(!declaredVariables.contains(variable));
     String name = getVariableName(variable);
     VariableDeclaration decl = new VariableDeclaration(name, initializer);
     decl.element = variable.element;
     declaredVariables.add(variable);
     variables.add(decl);
   }
@@ skipping 152 matching lines @@
     fallthrough = savedFallthrough;
     statementBuffer = savedBuffer;
     visitStatement(stmt.next);
   }
 
   /// Generates a name for the given variable and synthesizes an element for it,
   /// if necessary.
   String getVariableName(tree.Variable variable) {
     // If the variable belongs to an enclosing function, ask the parent emitter
     // for the variable name.
-    if (variable.host.element != functionElement) {
+    if (variable.host != currentElement) {
       return parent.getVariableName(variable);
     }
 
     // Get the name if we already have one.
     String name = variableNames[variable];
     if (name != null) {
       return name;
     }
 
     // Synthesize a variable name that isn't used elsewhere.
     // The [usedVariableNames] set is shared between nested emitters,
     // so this also prevents clash with variables in an enclosing/inner scope.
     // The renaming phase after codegen will further prefix local variables
     // so they cannot clash with top-level variables or fields.
     String prefix = variable.element == null ? 'v' : variable.element.name;
     int counter = 0;
     name = variable.element == null ? '$prefix$counter' : variable.element.name;
     while (!usedVariableNames.add(name)) {
       ++counter;
       name = '$prefix$counter';
     }
     variableNames[variable] = name;
 
     // Synthesize an element for the variable
     if (variable.element == null || name != variable.element.name) {
       // TODO(johnniwinther): Replace by synthetic [Entity].
       variable.element = new _SyntheticLocalVariableElement(
           name,
-          functionElement,
+          currentElement,
           variableList);
     }
     return name;
   }
 
   String getConstantName(VariableElement element) {
     assert(element.kind == ElementKind.VARIABLE);
-    if (element.enclosingElement != functionElement) {
+    if (element.enclosingElement != currentElement) {
       return parent.getConstantName(element);
     }
     String name = constantNames[element];
     if (name != null) {
       return name;
     }
     String prefix = element.name;
     int counter = 0;
     name = element.name;
     while (!usedVariableNames.add(name)) {
@@ skipping 15 matching lines @@
       tree.FunctionExpression functionExp = stmt.definition;
       FunctionExpression function = makeSubFunction(functionExp.definition);
       FunctionDeclaration decl = new FunctionDeclaration(function);
       statementBuffer.add(decl);
       declaredVariables.add(stmt.variable);
       visitStatement(stmt.next);
       return;
     }
 
     bool isFirstOccurrence = (variableNames[stmt.variable] == null);
-    bool isDeclaredHere = stmt.variable.host.element == functionElement;
+    bool isDeclaredHere = stmt.variable.host == currentElement;
     String name = getVariableName(stmt.variable);
     Expression definition = visitExpression(stmt.definition);
 
     // Try to pull into initializer.
     if (firstStatement == stmt && isFirstOccurrence && isDeclaredHere) {
       if (isNullLiteral(definition)) definition = null;
       addDeclaration(stmt.variable, definition);
       firstStatement = stmt.next;
       visitStatement(stmt.next);
       return;
@@ skipping 460 matching lines @@
 
   /// Maps parameter names to their bindings.
   Map<String, tree.Variable> environment = <String, tree.Variable>{};
 
   /// Parameters that are currently shadowed by another parameter.
   Set<tree.Variable> shadowedParameters = new Set<tree.Variable>();
 
   /// Parameters that are used in a context where it is shadowed.
   Set<tree.Variable> hasShadowedUse = new Set<tree.Variable>();
 
-  void unshadow(tree.FunctionDefinition definition) {
-    if (definition.isAbstract) return;
-
+  void unshadow(tree.ExecutableDefinition definition) {
+    // Fields have no parameters.
+    if (definition is tree.FieldDefinition) return;
     visitFunctionDefinition(definition);
   }
 
   visitFunctionDefinition(tree.FunctionDefinition definition) {
+    if (definition.isAbstract) return;
     var oldShadow = shadowedParameters;
     var oldEnvironment = environment;
     environment = new Map<String, tree.Variable>.from(environment);
     shadowedParameters = new Set<tree.Variable>.from(shadowedParameters);
     for (tree.Variable param in definition.parameters) {
       tree.Variable oldVariable = environment[param.element.name];
       if (oldVariable != null) {
         shadowedParameters.add(oldVariable);
       }
       environment[param.element.name] = param;
     }
     visitStatement(definition.body);
     environment = oldEnvironment;
     shadowedParameters = oldShadow;
 
     for (int i=0; i<definition.parameters.length; i++) {
       tree.Variable param = definition.parameters[i];
       if (hasShadowedUse.remove(param)) {
-        tree.Variable newParam = new tree.Variable(definition, param.element);
+        tree.Variable newParam = new tree.Variable(definition.element,
+            param.element);
         definition.parameters[i] = newParam;
         definition.body = new tree.Assign(param, newParam, definition.body);
         newParam.writeCount = 1; // Being a parameter counts as a write.
       }
     }
   }
 
   visitVariable(tree.Variable variable) {
     if (shadowedParameters.contains(variable)) {
       hasShadowedUse.add(variable);
@@ skipping 13 matching lines @@
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }